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

package/dist/context/requestContainer.js

@@ -3,15 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MidwayRequestContainer = void 0;
 const container_1 = require("./container");
 const interface_1 = require("../interface");
-const util_1 = require("../util/");
 const decorator_1 = require("@midwayjs/decorator");
 class MidwayRequestContainer extends container_1.MidwayContainer {
     constructor(ctx, applicationContext) {
-        super(null, applicationContext);
+        super(applicationContext);
         this.applicationContext = applicationContext;
-        this.configService = this.applicationContext.getConfigService();
-        this.environmentService = this.applicationContext.getEnvironmentService();
-        this.aspectService = this.applicationContext.getAspectService();
+        // update legacy relationship
+        this.registry.setIdentifierRelation(this.applicationContext.registry.getIdentifierRelation());
         this.ctx = ctx;
         // register ctx
         this.registerObject(interface_1.REQUEST_CTX_KEY, ctx);
@@ -19,31 +17,26 @@ class MidwayRequestContainer extends container_1.MidwayContainer {
             // register contextLogger
             this.registerObject('logger', ctx.logger);
         }
-        const resolverHandler = this.applicationContext.getResolverHandler();
-        this.beforeEachCreated(resolverHandler.beforeEachCreated.bind(resolverHandler));
-        this.afterEachCreated(resolverHandler.afterEachCreated.bind(resolverHandler));
     }
     init() {
         // do nothing
     }
     get(identifier, args) {
         if (typeof identifier !== 'string') {
-            identifier = decorator_1.getProviderId(identifier);
+            identifier = this.getIdentifier(identifier);
         }
         if (this.registry.hasObject(identifier)) {
-            const ins = this.registry.getObject(identifier);
-            return this.aspectService.wrapperAspectToInstance(ins);
+            return this.registry.getObject(identifier);
         }
         const definition = this.applicationContext.registry.getDefinition(identifier);
         if (definition) {
             if (definition.isRequestScope() ||
                 definition.id === decorator_1.PIPELINE_IDENTIFIER) {
                 // create object from applicationContext definition for requestScope
-                const ins = this.getManagedResolverFactory().create({
+                return this.getManagedResolverFactory().create({
                     definition,
                     args,
                 });
-                return this.aspectService.wrapperAspectToInstance(ins);
             }
         }
         if (this.parent) {
@@ -52,23 +45,20 @@ class MidwayRequestContainer extends container_1.MidwayContainer {
     }
     async getAsync(identifier, args) {
         if (typeof identifier !== 'string') {
-            identifier = decorator_1.getProviderId(identifier);
+            identifier = this.getIdentifier(identifier);
         }
-        identifier = util_1.parsePrefix(identifier);
         if (this.registry.hasObject(identifier)) {
-            const ins = this.registry.getObject(identifier);
-            return this.aspectService.wrapperAspectToInstance(ins);
+            return this.registry.getObject(identifier);
         }
         const definition = this.applicationContext.registry.getDefinition(identifier);
         if (definition) {
             if (definition.isRequestScope() ||
                 definition.id === decorator_1.PIPELINE_IDENTIFIER) {
                 // create object from applicationContext definition for requestScope
-                const ins = await this.getManagedResolverFactory().createAsync({
+                return this.getManagedResolverFactory().createAsync({
                     definition,
                     args,
                 });
-                return this.aspectService.wrapperAspectToInstance(ins);
             }
         }
         if (this.parent) {
@@ -76,15 +66,8 @@ class MidwayRequestContainer extends container_1.MidwayContainer {
         }
     }
     async ready() {
-        this.readied = true;
         // ignore other things
     }
-    getConfigService() {
-        return this.configService;
-    }
-    getEnvironmentService() {
-        return this.environmentService;
-    }
     getContext() {
         return this.ctx;
     }

package/dist/definitions/functionDefinition.d.ts

@@ -1,5 +1,5 @@
 import { IManagedInstance, ObjectIdentifier, ScopeEnum } from '@midwayjs/decorator';
-import { IProperties, IObjectCreator, IObjectDefinition, HandlerProp } from '../interface';
+import { IProperties, IObjectCreator, IObjectDefinition } from '../interface';
 export declare class FunctionDefinition implements IObjectDefinition {
     constructor();
     constructMethod: string;
@@ -16,16 +16,15 @@ export declare class FunctionDefinition implements IObjectDefinition {
     properties: IProperties;
     namespace: string;
     asynchronous: boolean;
-    handlerProps: HandlerProp[];
+    handlerProps: any[];
+    createFrom: any;
     protected innerAutowire: boolean;
     protected innerScope: ScopeEnum;
-    set autowire(autowire: boolean);
     getAttr(key: ObjectIdentifier): any;
     hasAttr(key: ObjectIdentifier): boolean;
     hasConstructorArgs(): boolean;
     hasDependsOn(): boolean;
     isAsync(): boolean;
-    isAutowire(): boolean;
     isDirect(): boolean;
     isExternal(): boolean;
     set scope(scope: ScopeEnum);

package/dist/definitions/functionDefinition.js

@@ -28,9 +28,6 @@ class FunctionDefinition {
         this.innerScope = decorator_1.ScopeEnum.Singleton;
         this.creator = new FunctionWrapperCreator(this);
     }
-    set autowire(autowire) {
-        this.innerAutowire = autowire;
-    }
     getAttr(key) { }
     hasAttr(key) {
         return false;
@@ -44,9 +41,6 @@ class FunctionDefinition {
     isAsync() {
         return this.asynchronous;
     }
-    isAutowire() {
-        return this.innerAutowire;
-    }
     isDirect() {
         return false;
     }

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 (decorator_1.isAsyncFunction(fn)) {
+            if ((0, decorator_1.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 (decorator_1.isGeneratorFunction(inst[this.definition.initMethod]) ||
-                decorator_1.isAsyncFunction(inst[this.definition.initMethod])) {
-                throw new Error(`${this.definition.id} not valid by context.get, Use context.getAsync instead!`);
+            if ((0, decorator_1.isGeneratorFunction)(inst[this.definition.initMethod]) ||
+                (0, decorator_1.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 (decorator_1.isPromise(rt)) {
-                    throw new Error(`${this.definition.id} not valid by context.get, Use context.getAsync instead!`);
+                if ((0, decorator_1.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 (decorator_1.isAsyncFunction(initFn)) {
+            if ((0, decorator_1.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 (decorator_1.isAsyncFunction(fn)) {
+            if ((0, decorator_1.isAsyncFunction)(fn)) {
                 await fn.call(obj);
             }
             else {

package/dist/definitions/objectDefinition.d.ts

@@ -1,10 +1,9 @@
-import { IObjectCreator, IObjectDefinition, HandlerProp } from '../interface';
+import { IObjectCreator, IObjectDefinition } from '../interface';
 import { ScopeEnum, ObjectIdentifier } from '@midwayjs/decorator';
 import { ObjectProperties } from './properties';
 export declare class ObjectDefinition implements IObjectDefinition {
-    protected _attrs: Map<string, any>;
+    protected _attrs: Map<ObjectIdentifier, any>;
     protected _asynchronous: boolean;
-    protected _autowire: boolean;
     scope: ScopeEnum;
     creator: IObjectCreator;
     id: string;
@@ -19,10 +18,9 @@ export declare class ObjectDefinition implements IObjectDefinition {
     dependsOn: ObjectIdentifier[];
     properties: ObjectProperties;
     namespace: string;
-    handlerProps: HandlerProp[];
+    handlerProps: any[];
+    createFrom: any;
     constructor();
-    set autowire(autowire: boolean);
-    isAutowire(): boolean;
     set asynchronous(asynchronous: boolean);
     isAsync(): boolean;
     isSingletonScope(): boolean;

package/dist/definitions/objectDefinition.js

@@ -9,8 +9,6 @@ class ObjectDefinition {
     constructor() {
         this._attrs = new Map();
         this._asynchronous = false;
-        // 对象定义默认需要自动装配
-        this._autowire = true;
         this.scope = decorator_1.ScopeEnum.Singleton;
         this.creator = null;
         this.id = null;
@@ -27,12 +25,6 @@ class ObjectDefinition {
         this.handlerProps = [];
         this.creator = new objectCreator_1.ObjectCreator(this);
     }
-    set autowire(autowire) {
-        this._autowire = autowire;
-    }
-    isAutowire() {
-        return this._autowire;
-    }
     set asynchronous(asynchronous) {
         this._asynchronous = asynchronous;
     }

package/dist/definitions/properties.d.ts

@@ -1,21 +1,8 @@
 import { ObjectIdentifier } from '@midwayjs/decorator';
 import { IProperties } from '../interface';
-export declare class ObjectProperties implements IProperties {
-    private innerConfig;
-    get size(): number;
-    keys(): ObjectIdentifier[];
-    get(key: ObjectIdentifier, ...args: any[]): any;
-    dup(key: ObjectIdentifier): any;
-    has(key: ObjectIdentifier): boolean;
-    set(key: ObjectIdentifier, value: any): any;
-    putAll(props: IProperties): void;
-    putObject(props: Record<string, unknown>, needClone?: boolean): void;
-    stringPropertyNames(): ObjectIdentifier[];
+export declare class ObjectProperties extends Map<ObjectIdentifier, any> implements IProperties {
+    propertyKeys(): ObjectIdentifier[];
     getProperty(key: ObjectIdentifier, defaultValue?: any): any;
-    addProperty(key: ObjectIdentifier, value: any): void;
     setProperty(key: ObjectIdentifier, value: any): any;
-    clear(): void;
-    toJSON(): Record<string, unknown>;
-    clone(): IProperties;
 }
 //# sourceMappingURL=properties.d.ts.map

package/dist/definitions/properties.js

@@ -1,64 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectProperties = void 0;
-const _ = require("../common/lodashWrap");
-const util_1 = require("util");
-class ObjectProperties {
-    constructor() {
-        this.innerConfig = {};
-    }
-    get size() {
-        return this.keys().length;
-    }
-    keys() {
-        return Object.keys(this.innerConfig);
-    }
-    get(key, ...args) {
-        if (args && args.length > 0) {
-            args.unshift(_.get(this.innerConfig, key));
-            // eslint-disable-next-line prefer-spread
-            return util_1.format.apply(null, args);
-        }
-        return _.get(this.innerConfig, key);
-    }
-    dup(key) {
-        if (!this.has(key)) {
-            return null;
-        }
-        return JSON.parse(JSON.stringify(_.get(this.innerConfig, key)));
-    }
-    has(key) {
-        return this.innerConfig[key] !== undefined;
-    }
-    set(key, value) {
-        const origin = this.get(key);
-        _.set(this.innerConfig, key, value);
-        return origin;
-    }
-    putAll(props) {
-        const keys = props.keys();
-        for (const key of keys) {
-            if (typeof this.innerConfig[key] === 'object') {
-                this.set(key, _.defaultsDeep(props.get(key), this.innerConfig[key]));
-            }
-            else {
-                this.set(key, props.get(key));
-            }
-        }
-    }
-    putObject(props, needClone = false) {
-        if (needClone) {
-            const tmp = _.cloneDeep(props);
-            _.defaultsDeep(tmp, this.innerConfig);
-            this.innerConfig = tmp;
-        }
-        else {
-            _.defaultsDeep(props, this.innerConfig);
-            this.innerConfig = props;
-        }
-    }
-    stringPropertyNames() {
-        return this.keys();
+class ObjectProperties extends Map {
+    propertyKeys() {
+        return Array.from(this.keys());
     }
     getProperty(key, defaultValue) {
         if (this.has(key)) {
@@ -66,23 +11,9 @@ class ObjectProperties {
         }
         return defaultValue;
     }
-    addProperty(key, value) {
-        this.set(key, value);
-    }
     setProperty(key, value) {
         return this.set(key, value);
     }
-    clear() {
-        this.innerConfig = {};
-    }
-    toJSON() {
-        return JSON.parse(JSON.stringify(this.innerConfig));
-    }
-    clone() {
-        const cfg = new ObjectProperties();
-        cfg.putObject(this.toJSON());
-        return cfg;
-    }
 }
 exports.ObjectProperties = ObjectProperties;
 //# sourceMappingURL=properties.js.map

package/dist/error/base.d.ts

@@ -0,0 +1,32 @@
+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 | string;
+    cause: Error;
+    constructor(message: string, 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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 (!code || typeof code === 'object') {
+            options = code;
+            code = 'MIDWAY_10000';
+        }
+        this.name = this.constructor.name;
+        this.code = code;
+        this.cause = options === null || options === void 0 ? void 0 : options.cause;
+    }
+}
+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

@@ -0,0 +1,45 @@
+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";
+};
+export declare class MidwayCommonError extends MidwayError {
+    constructor(message: string);
+}
+export declare class MidwayParameterError extends MidwayError {
+    constructor(message?: string);
+}
+export declare class MidwayDefinitionNotFoundError extends MidwayError {
+    static readonly type: unique symbol;
+    static isClosePrototypeOf(ins: MidwayDefinitionNotFoundError): boolean;
+    constructor(identifier: ObjectIdentifier);
+    updateErrorMsg(className: string): void;
+}
+export declare class MidwayFeatureNoLongerSupportedError extends MidwayError {
+    constructor(message?: string);
+}
+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);
+}
+//# sourceMappingURL=framework.d.ts.map

package/dist/error/framework.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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,
+    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,
+});
+class MidwayCommonError extends base_1.MidwayError {
+    constructor(message) {
+        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', exports.FrameworkErrorEnum.PARAM_TYPE);
+    }
+}
+exports.MidwayParameterError = MidwayParameterError;
+class MidwayDefinitionNotFoundError extends base_1.MidwayError {
+    constructor(identifier) {
+        super(`${identifier} is not valid in current context`, exports.FrameworkErrorEnum.DEFINITION_NOT_FOUND);
+        this[MidwayDefinitionNotFoundError.type] =
+            MidwayDefinitionNotFoundError.type;
+    }
+    static isClosePrototypeOf(ins) {
+        return ins
+            ? ins[MidwayDefinitionNotFoundError.type] ===
+                MidwayDefinitionNotFoundError.type
+            : false;
+    }
+    updateErrorMsg(className) {
+        const identifier = this.message.split(' is not valid in current context')[0];
+        this.message = `${identifier} in class ${className} is not valid in current context`;
+    }
+}
+exports.MidwayDefinitionNotFoundError = MidwayDefinitionNotFoundError;
+MidwayDefinitionNotFoundError.type = Symbol.for('#NotFoundError');
+class MidwayFeatureNoLongerSupportedError extends base_1.MidwayError {
+    constructor(message) {
+        super('This feature no longer supported \n' + message, exports.FrameworkErrorEnum.FEATURE_NO_LONGER_SUPPORTED);
+    }
+}
+exports.MidwayFeatureNoLongerSupportedError = MidwayFeatureNoLongerSupportedError;
+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;
+//# sourceMappingURL=framework.js.map