@midwayjs/core 3.0.0-beta.6 → 3.0.0

package/dist/context/container.js

@@ -64,8 +64,13 @@ class ContainerConfiguration {
         });
     }
     addImportConfigs(importConfigs) {
-        if (importConfigs && importConfigs.length) {
-            this.container.get(configService_1.MidwayConfigService).add(importConfigs);
+        if (importConfigs) {
+            if (Array.isArray(importConfigs)) {
+                this.container.get(configService_1.MidwayConfigService).add(importConfigs);
+            }
+            else {
+                this.container.get(configService_1.MidwayConfigService).addObject(importConfigs);
+            }
         }
     }
     addImports(imports = []) {
@@ -139,16 +144,16 @@ class ContainerConfiguration {
     }
     getConfigurationExport(exports) {
         const mods = [];
-        if ((0, decorator_1.isClass)(exports) ||
-            (0, decorator_1.isFunction)(exports) ||
+        if (decorator_1.Types.isClass(exports) ||
+            decorator_1.Types.isFunction(exports) ||
             exports instanceof configuration_1.FunctionalConfiguration) {
             mods.push(exports);
         }
         else {
             for (const m in exports) {
                 const module = exports[m];
-                if ((0, decorator_1.isClass)(module) ||
-                    (0, decorator_1.isFunction)(module) ||
+                if (decorator_1.Types.isClass(module) ||
+                    decorator_1.Types.isFunction(module) ||
                     module instanceof configuration_1.FunctionalConfiguration) {
                     mods.push(module);
                 }
@@ -235,13 +240,13 @@ class MidwayContainer {
         (_a = this.fileDetector) === null || _a === void 0 ? void 0 : _a.run(this);
     }
     bindClass(exports, options) {
-        if ((0, decorator_1.isClass)(exports) || (0, decorator_1.isFunction)(exports)) {
+        if (decorator_1.Types.isClass(exports) || decorator_1.Types.isFunction(exports)) {
             this.bindModule(exports, options);
         }
         else {
             for (const m in exports) {
                 const module = exports[m];
-                if ((0, decorator_1.isClass)(module) || (0, decorator_1.isFunction)(module)) {
+                if (decorator_1.Types.isClass(module) || decorator_1.Types.isFunction(module)) {
                     this.bindModule(module, options);
                 }
             }
@@ -249,7 +254,7 @@ class MidwayContainer {
     }
     bind(identifier, target, options) {
         var _a;
-        if ((0, decorator_1.isClass)(identifier) || (0, decorator_1.isFunction)(identifier)) {
+        if (decorator_1.Types.isClass(identifier) || decorator_1.Types.isFunction(identifier)) {
             return this.bindModule(identifier, target);
         }
         if (this.registry.hasDefinition(identifier)) {
@@ -257,13 +262,13 @@ class MidwayContainer {
             return;
         }
         let definition;
-        if ((0, decorator_1.isClass)(target)) {
+        if (decorator_1.Types.isClass(target)) {
             definition = new objectDefinition_1.ObjectDefinition();
             definition.name = (0, decorator_1.getProviderName)(target);
         }
         else {
             definition = new functionDefinition_1.FunctionDefinition();
-            if (!(0, decorator_1.isAsyncFunction)(target)) {
+            if (!decorator_1.Types.isAsyncFunction(target)) {
                 definition.asynchronous = false;
             }
             definition.name = definition.id;
@@ -310,6 +315,10 @@ class MidwayContainer {
             debugBind(`  register scope = ${objDefOptions.scope}`);
             definition.scope = objDefOptions.scope;
         }
+        if (objDefOptions.allowDowngrade) {
+            debugBind(`  register allowDowngrade = ${objDefOptions.allowDowngrade}`);
+            definition.allowDowngrade = objDefOptions.allowDowngrade;
+        }
         this.objectCreateEventTarget.emit(interface_1.ObjectLifeCycleEvent.BEFORE_BIND, target, {
             context: this,
             definition,
@@ -322,7 +331,7 @@ class MidwayContainer {
         }
     }
     bindModule(module, options) {
-        if ((0, decorator_1.isClass)(module)) {
+        if (decorator_1.Types.isClass(module)) {
             const providerId = (0, decorator_1.getProviderUUId)(module);
             if (providerId) {
                 this.identifierMapping.saveClassRelation(module, options === null || options === void 0 ? void 0 : options.namespace);
@@ -338,7 +347,7 @@ class MidwayContainer {
                 if (!info.scope) {
                     info.scope = decorator_1.ScopeEnum.Request;
                 }
-                const uuid = (0, decorator_1.generateRandomId)();
+                const uuid = decorator_1.Utils.generateRandomId();
                 this.identifierMapping.saveFunctionRelation(info.id, uuid);
                 this.bind(uuid, module, {
                     scope: info.scope,
@@ -379,7 +388,10 @@ class MidwayContainer {
     }
     get(identifier, args, objectContext) {
         var _a;
+        args = args !== null && args !== void 0 ? args : [];
+        objectContext = objectContext !== null && objectContext !== void 0 ? objectContext : { originName: identifier };
         if (typeof identifier !== 'string') {
+            objectContext.originName = identifier.name;
             identifier = this.getIdentifier(identifier);
         }
         if (this.registry.hasObject(identifier)) {
@@ -396,7 +408,10 @@ class MidwayContainer {
     }
     async getAsync(identifier, args, objectContext) {
         var _a;
+        args = args !== null && args !== void 0 ? args : [];
+        objectContext = objectContext !== null && objectContext !== void 0 ? objectContext : { originName: identifier };
         if (typeof identifier !== 'string') {
+            objectContext.originName = identifier.name;
             identifier = this.getIdentifier(identifier);
         }
         if (this.registry.hasObject(identifier)) {

package/dist/context/managedResolverFactory.js

@@ -56,14 +56,14 @@ class ManagedResolverFactory {
     resolveManaged(managed, originPropertyName) {
         const resolver = this.resolvers[managed.type];
         if (!resolver || resolver.type !== managed.type) {
-            throw new Error(`${managed.type} resolver is not exists!`);
+            throw new error_1.MidwayResolverMissingError(managed.type);
         }
         return resolver.resolve(managed, originPropertyName);
     }
     async resolveManagedAsync(managed, originPropertyName) {
         const resolver = this.resolvers[managed.type];
         if (!resolver || resolver.type !== managed.type) {
-            throw new Error(`${managed.type} resolver is not exists!`);
+            throw new error_1.MidwayResolverMissingError(managed.type);
         }
         return resolver.resolveAsync(managed, originPropertyName);
     }
@@ -89,7 +89,7 @@ class ManagedResolverFactory {
                 this.context.get(dep, args);
             }
         }
-        debugLog(`[core:container]: Create id = "${definition.name}" ${definition.id}.`);
+        debugLog(`[core]: Create id = "${definition.name}" ${definition.id}.`);
         const Clzz = definition.creator.load();
         let constructorArgs = [];
         if (args && Array.isArray(args) && args.length > 0) {
@@ -174,7 +174,7 @@ class ManagedResolverFactory {
                 await this.context.getAsync(dep, args);
             }
         }
-        debugLog(`[core:container]: Create id = "${definition.name}" ${definition.id}.`);
+        debugLog(`[core]: Create id = "${definition.name}" ${definition.id}.`);
         const Clzz = definition.creator.load();
         let constructorArgs = [];
         if (args && Array.isArray(args) && args.length > 0) {
@@ -187,7 +187,7 @@ class ManagedResolverFactory {
         inst = await definition.creator.doConstructAsync(Clzz, constructorArgs, this.context);
         if (!inst) {
             this.removeCreateStatus(definition, false);
-            throw new Error(`${definition.id} construct return undefined`);
+            throw new error_1.MidwayCommonError(`${definition.id} construct return undefined`);
         }
         // binding ctx object
         if (definition.isRequestScope() &&
@@ -202,6 +202,13 @@ class ManagedResolverFactory {
         if (definition.properties) {
             const keys = definition.properties.propertyKeys();
             for (const key of keys) {
+                if (definition.isSingletonScope() && this.context.hasDefinition(key)) {
+                    const propertyDefinition = this.context.registry.getDefinition(key);
+                    if (propertyDefinition.isRequestScope() &&
+                        !propertyDefinition.allowDowngrade) {
+                        throw new error_1.MidwaySingletonInjectRequestError(definition.path.name, propertyDefinition.path.name);
+                    }
+                }
                 try {
                     inst[key] = await this.resolveManagedAsync(definition.properties.get(key), key);
                 }

package/dist/context/requestContainer.js

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

package/dist/definitions/functionDefinition.d.ts

@@ -18,6 +18,7 @@ export declare class FunctionDefinition implements IObjectDefinition {
     asynchronous: boolean;
     handlerProps: any[];
     createFrom: any;
+    allowDowngrade: boolean;
     protected innerAutowire: boolean;
     protected innerScope: ScopeEnum;
     getAttr(key: ObjectIdentifier): any;

package/dist/definitions/functionDefinition.js

@@ -23,6 +23,7 @@ class FunctionDefinition {
         this.namespace = '';
         this.asynchronous = true;
         this.handlerProps = [];
+        this.allowDowngrade = false;
         // 函数工厂创建的对象默认不需要自动装配
         this.innerAutowire = false;
         this.innerScope = decorator_1.ScopeEnum.Singleton;

package/dist/definitions/objectCreator.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectCreator = void 0;
 const decorator_1 = require("@midwayjs/decorator");
+const error_1 = require("../error");
 class ObjectCreator {
     constructor(definition) {
         this.definition = definition;
@@ -64,7 +65,7 @@ class ObjectCreator {
         let inst;
         if (this.definition.constructMethod) {
             const fn = Clzz[this.definition.constructMethod];
-            if ((0, decorator_1.isAsyncFunction)(fn)) {
+            if (decorator_1.Types.isAsyncFunction(fn)) {
                 inst = await fn.apply(Clzz, args);
             }
             else {
@@ -85,14 +86,14 @@ class ObjectCreator {
         const inst = obj;
         // after properties set then do init
         if (this.definition.initMethod && inst[this.definition.initMethod]) {
-            if ((0, decorator_1.isGeneratorFunction)(inst[this.definition.initMethod]) ||
-                (0, decorator_1.isAsyncFunction)(inst[this.definition.initMethod])) {
-                throw new Error(`${this.definition.id} not valid by context.get, Use context.getAsync instead!`);
+            if (decorator_1.Types.isGeneratorFunction(inst[this.definition.initMethod]) ||
+                decorator_1.Types.isAsyncFunction(inst[this.definition.initMethod])) {
+                throw new error_1.MidwayUseWrongMethodError('context.get', 'context.getAsync', this.definition.id);
             }
             else {
                 const rt = inst[this.definition.initMethod].call(inst);
-                if ((0, decorator_1.isPromise)(rt)) {
-                    throw new Error(`${this.definition.id} not valid by context.get, Use context.getAsync instead!`);
+                if (decorator_1.Types.isPromise(rt)) {
+                    throw new error_1.MidwayUseWrongMethodError('context.get', 'context.getAsync', this.definition.id);
                 }
             }
         }
@@ -106,7 +107,7 @@ class ObjectCreator {
         const inst = obj;
         if (this.definition.initMethod && inst[this.definition.initMethod]) {
             const initFn = inst[this.definition.initMethod];
-            if ((0, decorator_1.isAsyncFunction)(initFn)) {
+            if (decorator_1.Types.isAsyncFunction(initFn)) {
                 await initFn.call(inst);
             }
             else {
@@ -139,7 +140,7 @@ class ObjectCreator {
     async doDestroyAsync(obj) {
         if (this.definition.destroyMethod && obj[this.definition.destroyMethod]) {
             const fn = obj[this.definition.destroyMethod];
-            if ((0, decorator_1.isAsyncFunction)(fn)) {
+            if (decorator_1.Types.isAsyncFunction(fn)) {
                 await fn.call(obj);
             }
             else {

package/dist/definitions/objectDefinition.d.ts

@@ -20,6 +20,7 @@ export declare class ObjectDefinition implements IObjectDefinition {
     namespace: string;
     handlerProps: any[];
     createFrom: any;
+    allowDowngrade: boolean;
     constructor();
     set asynchronous(asynchronous: boolean);
     isAsync(): boolean;

package/dist/definitions/objectDefinition.js

@@ -23,6 +23,7 @@ class ObjectDefinition {
         this.properties = new properties_1.ObjectProperties();
         this.namespace = '';
         this.handlerProps = [];
+        this.allowDowngrade = false;
         this.creator = new objectCreator_1.ObjectCreator(this);
     }
     set asynchronous(asynchronous) {

package/dist/error/base.d.ts

@@ -2,12 +2,31 @@ interface ErrorOption {
     cause?: Error;
     status?: number;
 }
+interface Convertable {
+    [key: string]: string | number;
+}
+declare type ConvertString<T extends Convertable, Group extends string> = {
+    [P in keyof T]: P extends string ? T[P] extends number ? `${Uppercase<Group>}_${T[P]}` : never : never;
+};
+/**
+ * Register error group and code, return the standard ErrorCode
+ * @param errorGroup
+ * @param errorCodeMapping
+ */
+export declare function registerErrorCode<T extends Convertable, G extends string>(errorGroup: G, errorCodeMapping: T): ConvertString<T, G>;
 export declare class MidwayError extends Error {
-    code: number;
-    status: number;
+    code: number | string;
     cause: Error;
     constructor(message: string, options?: ErrorOption);
-    constructor(message: string, code: number, options?: ErrorOption);
+    constructor(message: string, code: string, options?: ErrorOption);
+}
+export declare type ResOrMessage = string | {
+    message: string;
+};
+export declare class MidwayHttpError extends MidwayError {
+    status: number;
+    constructor(resOrMessage: ResOrMessage, status: number);
+    constructor(resOrMessage: ResOrMessage, status: number, code: string, options?: ErrorOption);
 }
 export {};
 //# sourceMappingURL=base.d.ts.map

package/dist/error/base.js

@@ -1,19 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MidwayError = void 0;
-const code_1 = require("./code");
+exports.MidwayHttpError = exports.MidwayError = exports.registerErrorCode = void 0;
+const codeGroup = new Set();
+/**
+ * Register error group and code, return the standard ErrorCode
+ * @param errorGroup
+ * @param errorCodeMapping
+ */
+function registerErrorCode(errorGroup, errorCodeMapping) {
+    if (codeGroup.has(errorGroup)) {
+        throw new MidwayError(`Error group ${errorGroup} is duplicated, please check before adding.`);
+    }
+    else {
+        codeGroup.add(errorGroup);
+    }
+    const newCodeEnum = {};
+    // ERROR => GROUP_10000
+    for (const errKey in errorCodeMapping) {
+        newCodeEnum[errKey] =
+            errorGroup.toUpperCase() +
+                '_' +
+                String(errorCodeMapping[errKey]).toUpperCase();
+    }
+    return newCodeEnum;
+}
+exports.registerErrorCode = registerErrorCode;
 class MidwayError extends Error {
     constructor(message, code, options) {
         super(message);
-        if (typeof code !== 'number') {
+        if (!code || typeof code === 'object') {
             options = code;
-            code = code_1.FrameworkErrorEnum.UNKNOWN;
+            code = 'MIDWAY_10000';
         }
         this.name = this.constructor.name;
         this.code = code;
         this.cause = options === null || options === void 0 ? void 0 : options.cause;
-        this.status = options === null || options === void 0 ? void 0 : options.status;
     }
 }
 exports.MidwayError = MidwayError;
+class MidwayHttpError extends MidwayError {
+    constructor(resOrMessage, status, code, options) {
+        super(typeof resOrMessage === 'string' ? resOrMessage : resOrMessage.message, code !== null && code !== void 0 ? code : String(status), options);
+        this.status = status;
+    }
+}
+exports.MidwayHttpError = MidwayHttpError;
 //# sourceMappingURL=base.js.map

package/dist/error/framework.d.ts

@@ -1,5 +1,18 @@
 import { MidwayError } from './base';
 import { ObjectIdentifier } from '@midwayjs/decorator';
+export declare const FrameworkErrorEnum: {
+    readonly UNKNOWN: "MIDWAY_10000";
+    readonly COMMON: "MIDWAY_10001";
+    readonly PARAM_TYPE: "MIDWAY_10002";
+    readonly DEFINITION_NOT_FOUND: "MIDWAY_10003";
+    readonly FEATURE_NO_LONGER_SUPPORTED: "MIDWAY_10004";
+    readonly FEATURE_NOT_IMPLEMENTED: "MIDWAY_10004";
+    readonly MISSING_CONFIG: "MIDWAY_10006";
+    readonly MISSING_RESOLVER: "MIDWAY_10007";
+    readonly DUPLICATE_ROUTER: "MIDWAY_10008";
+    readonly USE_WRONG_METHOD: "MIDWAY_10009";
+    readonly SINGLETON_INJECT_REQUEST: "MIDWAY_10010";
+};
 export declare class MidwayCommonError extends MidwayError {
     constructor(message: string);
 }
@@ -15,7 +28,22 @@ export declare class MidwayDefinitionNotFoundError extends MidwayError {
 export declare class MidwayFeatureNoLongerSupportedError extends MidwayError {
     constructor(message?: string);
 }
-export declare class MidwayValidationError extends MidwayError {
-    constructor(message: any, status: any, cause: any);
+export declare class MidwayFeatureNotImplementedError extends MidwayError {
+    constructor(message?: string);
+}
+export declare class MidwayConfigMissingError extends MidwayError {
+    constructor(configKey: string);
+}
+export declare class MidwayResolverMissingError extends MidwayError {
+    constructor(type: string);
+}
+export declare class MidwayDuplicateRouteError extends MidwayError {
+    constructor(routerUrl: string, existPos: string, existPosOther: string);
+}
+export declare class MidwayUseWrongMethodError extends MidwayError {
+    constructor(wrongMethod: string, replacedMethod: string, describeKey?: string);
+}
+export declare class MidwaySingletonInjectRequestError extends MidwayError {
+    constructor(singletonScopeName: string, requestScopeName: string);
 }
 //# sourceMappingURL=framework.d.ts.map

package/dist/error/framework.js

@@ -1,23 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MidwayValidationError = exports.MidwayFeatureNoLongerSupportedError = exports.MidwayDefinitionNotFoundError = exports.MidwayParameterError = exports.MidwayCommonError = void 0;
+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");
-const code_1 = require("./code");
+exports.FrameworkErrorEnum = (0, base_1.registerErrorCode)('midway', {
+    UNKNOWN: 10000,
+    COMMON: 10001,
+    PARAM_TYPE: 10002,
+    DEFINITION_NOT_FOUND: 10003,
+    FEATURE_NO_LONGER_SUPPORTED: 10004,
+    FEATURE_NOT_IMPLEMENTED: 10004,
+    MISSING_CONFIG: 10006,
+    MISSING_RESOLVER: 10007,
+    DUPLICATE_ROUTER: 10008,
+    USE_WRONG_METHOD: 10009,
+    SINGLETON_INJECT_REQUEST: 10010,
+});
 class MidwayCommonError extends base_1.MidwayError {
     constructor(message) {
-        super(message, code_1.FrameworkErrorEnum.COMMON);
+        super(message, exports.FrameworkErrorEnum.COMMON);
     }
 }
 exports.MidwayCommonError = MidwayCommonError;
 class MidwayParameterError extends base_1.MidwayError {
     constructor(message) {
-        super(message !== null && message !== void 0 ? message : 'Parameter type not match', code_1.FrameworkErrorEnum.PARAM_TYPE);
+        super(message !== null && message !== void 0 ? message : 'Parameter type not match', exports.FrameworkErrorEnum.PARAM_TYPE);
     }
 }
 exports.MidwayParameterError = MidwayParameterError;
 class MidwayDefinitionNotFoundError extends base_1.MidwayError {
     constructor(identifier) {
-        super(`${identifier} is not valid in current context`, code_1.FrameworkErrorEnum.DEFINITION_NOT_FOUND);
+        super(`${identifier} is not valid in current context`, exports.FrameworkErrorEnum.DEFINITION_NOT_FOUND);
         this[MidwayDefinitionNotFoundError.type] =
             MidwayDefinitionNotFoundError.type;
     }
@@ -36,17 +48,48 @@ exports.MidwayDefinitionNotFoundError = MidwayDefinitionNotFoundError;
 MidwayDefinitionNotFoundError.type = Symbol.for('#NotFoundError');
 class MidwayFeatureNoLongerSupportedError extends base_1.MidwayError {
     constructor(message) {
-        super('This feature no longer supported \n' + message, code_1.FrameworkErrorEnum.FEATURE_NO_LONGER_SUPPORTED);
+        super('This feature no longer supported \n' + message, exports.FrameworkErrorEnum.FEATURE_NO_LONGER_SUPPORTED);
     }
 }
 exports.MidwayFeatureNoLongerSupportedError = MidwayFeatureNoLongerSupportedError;
-class MidwayValidationError extends base_1.MidwayError {
-    constructor(message, status, cause) {
-        super(message, code_1.FrameworkErrorEnum.VALIDATE_FAIL, {
-            status,
-            cause,
-        });
+class MidwayFeatureNotImplementedError extends base_1.MidwayError {
+    constructor(message) {
+        super('This feature not implemented \n' + message, exports.FrameworkErrorEnum.FEATURE_NOT_IMPLEMENTED);
+    }
+}
+exports.MidwayFeatureNotImplementedError = MidwayFeatureNotImplementedError;
+class MidwayConfigMissingError extends base_1.MidwayError {
+    constructor(configKey) {
+        super(`Can't found config key "${configKey}" in your config, please set it first`, exports.FrameworkErrorEnum.MISSING_CONFIG);
+    }
+}
+exports.MidwayConfigMissingError = MidwayConfigMissingError;
+class MidwayResolverMissingError extends base_1.MidwayError {
+    constructor(type) {
+        super(`${type} resolver is not exists!`, exports.FrameworkErrorEnum.MISSING_RESOLVER);
+    }
+}
+exports.MidwayResolverMissingError = MidwayResolverMissingError;
+class MidwayDuplicateRouteError extends base_1.MidwayError {
+    constructor(routerUrl, existPos, existPosOther) {
+        super(`Duplicate router "${routerUrl}" at "${existPos}" and "${existPosOther}"`, exports.FrameworkErrorEnum.DUPLICATE_ROUTER);
+    }
+}
+exports.MidwayDuplicateRouteError = MidwayDuplicateRouteError;
+class MidwayUseWrongMethodError extends base_1.MidwayError {
+    constructor(wrongMethod, replacedMethod, describeKey) {
+        const text = describeKey
+            ? `${describeKey} not valid by ${wrongMethod}, Use ${replacedMethod} instead!`
+            : `You should not invoked by ${wrongMethod}, Use ${replacedMethod} instead!`;
+        super(text, exports.FrameworkErrorEnum.USE_WRONG_METHOD);
+    }
+}
+exports.MidwayUseWrongMethodError = MidwayUseWrongMethodError;
+class MidwaySingletonInjectRequestError extends base_1.MidwayError {
+    constructor(singletonScopeName, requestScopeName) {
+        const text = `${singletonScopeName} with singleton scope can't implicitly inject ${requestScopeName} with request scope directly, please add @Scope(ScopeEnum.Request, { allowDowngrade: true }) in ${requestScopeName}.`;
+        super(text, exports.FrameworkErrorEnum.SINGLETON_INJECT_REQUEST);
     }
 }
-exports.MidwayValidationError = MidwayValidationError;
+exports.MidwaySingletonInjectRequestError = MidwaySingletonInjectRequestError;
 //# sourceMappingURL=framework.js.map