@midwayjs/core 3.0.0-alpha.6 → 3.0.0-beta.11

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

@@ -64,7 +64,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,13 +85,13 @@ 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])) {
+            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!`);
             }
             else {
                 const rt = inst[this.definition.initMethod].call(inst);
-                if (decorator_1.isPromise(rt)) {
+                if ((0, decorator_1.isPromise)(rt)) {
                     throw new Error(`${this.definition.id} not valid by context.get, Use context.getAsync instead!`);
                 }
             }
@@ -106,7 +106,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 +139,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,13 @@
+interface ErrorOption {
+    cause?: Error;
+    status?: number;
+}
+export declare class MidwayError extends Error {
+    code: number;
+    status: number;
+    cause: Error;
+    constructor(message: string, options?: ErrorOption);
+    constructor(message: string, code: number, options?: ErrorOption);
+}
+export {};
+//# sourceMappingURL=base.d.ts.map

package/dist/error/base.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MidwayError = void 0;
+const code_1 = require("./code");
+class MidwayError extends Error {
+    constructor(message, code, options) {
+        super(message);
+        if (typeof code !== 'number') {
+            options = code;
+            code = code_1.FrameworkErrorEnum.UNKNOWN;
+        }
+        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;
+//# sourceMappingURL=base.js.map

package/dist/error/code.d.ts

@@ -0,0 +1,60 @@
+export declare enum HttpStatus {
+    CONTINUE = 100,
+    SWITCHING_PROTOCOLS = 101,
+    PROCESSING = 102,
+    EARLYHINTS = 103,
+    OK = 200,
+    CREATED = 201,
+    ACCEPTED = 202,
+    NON_AUTHORITATIVE_INFORMATION = 203,
+    NO_CONTENT = 204,
+    RESET_CONTENT = 205,
+    PARTIAL_CONTENT = 206,
+    AMBIGUOUS = 300,
+    MOVED_PERMANENTLY = 301,
+    FOUND = 302,
+    SEE_OTHER = 303,
+    NOT_MODIFIED = 304,
+    TEMPORARY_REDIRECT = 307,
+    PERMANENT_REDIRECT = 308,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    PAYMENT_REQUIRED = 402,
+    FORBIDDEN = 403,
+    NOT_FOUND = 404,
+    METHOD_NOT_ALLOWED = 405,
+    NOT_ACCEPTABLE = 406,
+    PROXY_AUTHENTICATION_REQUIRED = 407,
+    REQUEST_TIMEOUT = 408,
+    CONFLICT = 409,
+    GONE = 410,
+    LENGTH_REQUIRED = 411,
+    PRECONDITION_FAILED = 412,
+    PAYLOAD_TOO_LARGE = 413,
+    URI_TOO_LONG = 414,
+    UNSUPPORTED_MEDIA_TYPE = 415,
+    REQUESTED_RANGE_NOT_SATISFIABLE = 416,
+    EXPECTATION_FAILED = 417,
+    I_AM_A_TEAPOT = 418,
+    MISDIRECTED = 421,
+    UNPROCESSABLE_ENTITY = 422,
+    FAILED_DEPENDENCY = 424,
+    PRECONDITION_REQUIRED = 428,
+    TOO_MANY_REQUESTS = 429,
+    INTERNAL_SERVER_ERROR = 500,
+    NOT_IMPLEMENTED = 501,
+    BAD_GATEWAY = 502,
+    SERVICE_UNAVAILABLE = 503,
+    GATEWAY_TIMEOUT = 504,
+    HTTP_VERSION_NOT_SUPPORTED = 505
+}
+export declare enum FrameworkErrorEnum {
+    UNKNOWN = 10000,
+    COMMON = 10001,
+    PARAM_TYPE = 10002,
+    DEFINITION_NOT_FOUND = 10003,
+    FEATURE_NO_LONGER_SUPPORTED = 10004,
+    VALIDATE_FAIL = 10005,
+    MISSING_CONFIG = 10006
+}
+//# sourceMappingURL=code.d.ts.map

package/dist/error/code.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrameworkErrorEnum = exports.HttpStatus = void 0;
+var HttpStatus;
+(function (HttpStatus) {
+    HttpStatus[HttpStatus["CONTINUE"] = 100] = "CONTINUE";
+    HttpStatus[HttpStatus["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
+    HttpStatus[HttpStatus["PROCESSING"] = 102] = "PROCESSING";
+    HttpStatus[HttpStatus["EARLYHINTS"] = 103] = "EARLYHINTS";
+    HttpStatus[HttpStatus["OK"] = 200] = "OK";
+    HttpStatus[HttpStatus["CREATED"] = 201] = "CREATED";
+    HttpStatus[HttpStatus["ACCEPTED"] = 202] = "ACCEPTED";
+    HttpStatus[HttpStatus["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
+    HttpStatus[HttpStatus["NO_CONTENT"] = 204] = "NO_CONTENT";
+    HttpStatus[HttpStatus["RESET_CONTENT"] = 205] = "RESET_CONTENT";
+    HttpStatus[HttpStatus["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
+    HttpStatus[HttpStatus["AMBIGUOUS"] = 300] = "AMBIGUOUS";
+    HttpStatus[HttpStatus["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+    HttpStatus[HttpStatus["FOUND"] = 302] = "FOUND";
+    HttpStatus[HttpStatus["SEE_OTHER"] = 303] = "SEE_OTHER";
+    HttpStatus[HttpStatus["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
+    HttpStatus[HttpStatus["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
+    HttpStatus[HttpStatus["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
+    HttpStatus[HttpStatus["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    HttpStatus[HttpStatus["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+    HttpStatus[HttpStatus["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
+    HttpStatus[HttpStatus["FORBIDDEN"] = 403] = "FORBIDDEN";
+    HttpStatus[HttpStatus["NOT_FOUND"] = 404] = "NOT_FOUND";
+    HttpStatus[HttpStatus["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+    HttpStatus[HttpStatus["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+    HttpStatus[HttpStatus["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
+    HttpStatus[HttpStatus["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+    HttpStatus[HttpStatus["CONFLICT"] = 409] = "CONFLICT";
+    HttpStatus[HttpStatus["GONE"] = 410] = "GONE";
+    HttpStatus[HttpStatus["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
+    HttpStatus[HttpStatus["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+    HttpStatus[HttpStatus["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+    HttpStatus[HttpStatus["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
+    HttpStatus[HttpStatus["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+    HttpStatus[HttpStatus["REQUESTED_RANGE_NOT_SATISFIABLE"] = 416] = "REQUESTED_RANGE_NOT_SATISFIABLE";
+    HttpStatus[HttpStatus["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
+    HttpStatus[HttpStatus["I_AM_A_TEAPOT"] = 418] = "I_AM_A_TEAPOT";
+    HttpStatus[HttpStatus["MISDIRECTED"] = 421] = "MISDIRECTED";
+    HttpStatus[HttpStatus["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+    HttpStatus[HttpStatus["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
+    HttpStatus[HttpStatus["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
+    HttpStatus[HttpStatus["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+    HttpStatus[HttpStatus["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+    HttpStatus[HttpStatus["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+    HttpStatus[HttpStatus["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+    HttpStatus[HttpStatus["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+    HttpStatus[HttpStatus["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+    HttpStatus[HttpStatus["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
+})(HttpStatus = exports.HttpStatus || (exports.HttpStatus = {}));
+var FrameworkErrorEnum;
+(function (FrameworkErrorEnum) {
+    FrameworkErrorEnum[FrameworkErrorEnum["UNKNOWN"] = 10000] = "UNKNOWN";
+    FrameworkErrorEnum[FrameworkErrorEnum["COMMON"] = 10001] = "COMMON";
+    FrameworkErrorEnum[FrameworkErrorEnum["PARAM_TYPE"] = 10002] = "PARAM_TYPE";
+    FrameworkErrorEnum[FrameworkErrorEnum["DEFINITION_NOT_FOUND"] = 10003] = "DEFINITION_NOT_FOUND";
+    FrameworkErrorEnum[FrameworkErrorEnum["FEATURE_NO_LONGER_SUPPORTED"] = 10004] = "FEATURE_NO_LONGER_SUPPORTED";
+    FrameworkErrorEnum[FrameworkErrorEnum["VALIDATE_FAIL"] = 10005] = "VALIDATE_FAIL";
+    FrameworkErrorEnum[FrameworkErrorEnum["MISSING_CONFIG"] = 10006] = "MISSING_CONFIG";
+})(FrameworkErrorEnum = exports.FrameworkErrorEnum || (exports.FrameworkErrorEnum = {}));
+//# sourceMappingURL=code.js.map

package/dist/error/framework.d.ts

@@ -0,0 +1,24 @@
+import { MidwayError } from './base';
+import { ObjectIdentifier } from '@midwayjs/decorator';
+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 MidwayValidationError extends MidwayError {
+    constructor(message: any, status: any, cause: any);
+}
+export declare class MidwayConfigMissingError extends MidwayError {
+    constructor(configKey: string);
+}
+//# sourceMappingURL=framework.d.ts.map

package/dist/error/framework.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MidwayConfigMissingError = exports.MidwayValidationError = exports.MidwayFeatureNoLongerSupportedError = exports.MidwayDefinitionNotFoundError = exports.MidwayParameterError = exports.MidwayCommonError = void 0;
+const base_1 = require("./base");
+const code_1 = require("./code");
+class MidwayCommonError extends base_1.MidwayError {
+    constructor(message) {
+        super(message, code_1.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);
+    }
+}
+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);
+        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, code_1.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,
+        });
+    }
+}
+exports.MidwayValidationError = MidwayValidationError;
+class MidwayConfigMissingError extends base_1.MidwayError {
+    constructor(configKey) {
+        super(`Can't found config key "${configKey}" in your config, please set it first`, code_1.FrameworkErrorEnum.MISSING_CONFIG);
+    }
+}
+exports.MidwayConfigMissingError = MidwayConfigMissingError;
+//# sourceMappingURL=framework.js.map

package/dist/error/http.d.ts

@@ -0,0 +1,58 @@
+import { MidwayError } from './base';
+export declare class HttpError extends MidwayError {
+    status: number;
+    constructor(response: any, status: any);
+}
+export declare class BadRequestError extends HttpError {
+    constructor(response: any);
+}
+export declare class UnauthorizedError extends HttpError {
+}
+export declare class NotFoundError extends HttpError {
+}
+export declare class ForbiddenError extends HttpError {
+}
+export declare class NotAcceptableError extends HttpError {
+}
+export declare class RequestTimeoutError extends HttpError {
+}
+export declare class ConflictError extends HttpError {
+}
+export declare class GoneError extends HttpError {
+}
+export declare class PayloadTooLargeError extends HttpError {
+}
+export declare class UnsupportedMediaTypeError extends HttpError {
+}
+export declare class UnprocessableError extends HttpError {
+}
+export declare class InternalServerErrorError extends HttpError {
+}
+declare class NotImplementedError extends HttpError {
+}
+export declare class BadGatewayError extends HttpError {
+}
+export declare class ServiceUnavailableError extends HttpError {
+}
+export declare class GatewayTimeoutError extends HttpError {
+}
+export declare const http: {
+    BadRequestError: typeof BadRequestError;
+    UnauthorizedError: typeof UnauthorizedError;
+    NotFoundError: typeof NotFoundError;
+    ForbiddenError: typeof ForbiddenError;
+    NotAcceptableError: typeof NotAcceptableError;
+    RequestTimeoutError: typeof RequestTimeoutError;
+    ConflictError: typeof ConflictError;
+    GoneError: typeof GoneError;
+    PayloadTooLargeError: typeof PayloadTooLargeError;
+    UnsupportedMediaTypeError: typeof UnsupportedMediaTypeError;
+    UnprocessableError: typeof UnprocessableError;
+    InternalServerErrorError: typeof InternalServerErrorError;
+    NotImplementedError: typeof NotImplementedError;
+    BadGatewayError: typeof BadGatewayError;
+    ServiceUnavailableError: typeof ServiceUnavailableError;
+    GatewayTimeoutError: typeof GatewayTimeoutError;
+};
+export {};
+//# sourceMappingURL=http.d.ts.map

package/dist/error/http.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.http = exports.GatewayTimeoutError = exports.ServiceUnavailableError = exports.BadGatewayError = exports.InternalServerErrorError = exports.UnprocessableError = exports.UnsupportedMediaTypeError = exports.PayloadTooLargeError = exports.GoneError = exports.ConflictError = exports.RequestTimeoutError = exports.NotAcceptableError = exports.ForbiddenError = exports.NotFoundError = exports.UnauthorizedError = exports.BadRequestError = exports.HttpError = void 0;
+const code_1 = require("./code");
+const base_1 = require("./base");
+class HttpError extends base_1.MidwayError {
+    constructor(response, status) {
+        super(typeof response === 'string' ? response : response.message);
+        this.status = status;
+        this.name = this.constructor.name;
+    }
+}
+exports.HttpError = HttpError;
+class BadRequestError extends HttpError {
+    constructor(response) {
+        super(response, code_1.HttpStatus.BAD_REQUEST);
+    }
+}
+exports.BadRequestError = BadRequestError;
+class UnauthorizedError extends HttpError {
+}
+exports.UnauthorizedError = UnauthorizedError;
+class NotFoundError extends HttpError {
+}
+exports.NotFoundError = NotFoundError;
+class ForbiddenError extends HttpError {
+}
+exports.ForbiddenError = ForbiddenError;
+class NotAcceptableError extends HttpError {
+}
+exports.NotAcceptableError = NotAcceptableError;
+class RequestTimeoutError extends HttpError {
+}
+exports.RequestTimeoutError = RequestTimeoutError;
+class ConflictError extends HttpError {
+}
+exports.ConflictError = ConflictError;
+class GoneError extends HttpError {
+}
+exports.GoneError = GoneError;
+class PayloadTooLargeError extends HttpError {
+}
+exports.PayloadTooLargeError = PayloadTooLargeError;
+class UnsupportedMediaTypeError extends HttpError {
+}
+exports.UnsupportedMediaTypeError = UnsupportedMediaTypeError;
+class UnprocessableError extends HttpError {
+}
+exports.UnprocessableError = UnprocessableError;
+class InternalServerErrorError extends HttpError {
+}
+exports.InternalServerErrorError = InternalServerErrorError;
+class NotImplementedError extends HttpError {
+}
+class BadGatewayError extends HttpError {
+}
+exports.BadGatewayError = BadGatewayError;
+class ServiceUnavailableError extends HttpError {
+}
+exports.ServiceUnavailableError = ServiceUnavailableError;
+class GatewayTimeoutError extends HttpError {
+}
+exports.GatewayTimeoutError = GatewayTimeoutError;
+exports.http = {
+    BadRequestError,
+    UnauthorizedError,
+    NotFoundError,
+    ForbiddenError,
+    NotAcceptableError,
+    RequestTimeoutError,
+    ConflictError,
+    GoneError,
+    PayloadTooLargeError,
+    UnsupportedMediaTypeError,
+    UnprocessableError,
+    InternalServerErrorError,
+    NotImplementedError,
+    BadGatewayError,
+    ServiceUnavailableError,
+    GatewayTimeoutError,
+};
+//# sourceMappingURL=http.js.map

package/dist/error/index.d.ts

@@ -0,0 +1,4 @@
+export * from './base';
+export * from './http';
+export * from './framework';
+//# sourceMappingURL=index.d.ts.map

package/dist/error/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./base"), exports);
+__exportStar(require("./http"), exports);
+__exportStar(require("./framework"), exports);
+//# sourceMappingURL=index.js.map