		@@ -5,6 +5,2 @@ # Changelog

		### [1.0.6](https://github.com/koatty/koatty_exception/compare/v1.0.4...v1.0.6) (2021-11-18)

		### [1.0.4](https://github.com/koatty/koatty_exception/compare/v1.0.2...v1.0.4) (2021-11-17)

		### 1.0.2 (2021-11-16)
		### [1.1.1-0](https://github.com/koatty/koatty_exception/compare/v1.0.6...v1.1.1-0) (2022-02-14)

496

dist/index.d.ts

		@@ -1,2 +0,494 @@
		export * from "./exception";
		export * from "./code";
		/*!
		* @Author: richen
		* @Date: 2022-02-14 10:34:28
		* @License: BSD (3-Clause)
		* @Copyright (c) - <richenlin(at)gmail.com>
		* @HomePage: https://koatty.org/
		*/
		/// <reference types="node" />

		import { KoattyContext } from 'koatty_core';
		import { ServerResponse } from 'http';

		/**
		* Predefined runtime exception
		*
		* @export
		* @class HttpError
		* @extends {Error}
		*/
		export declare class Exception extends Error {
		status: number;
		code: number;
		readonly type = "Exception";
		/**
		* Creates an instance of Exception.
		* @param {string} message
		* @param {number} [code=1]
		* @param {number} [status]
		* @memberof Exception
		*/
		constructor(message: string, code?: number, status?: number);
		/**
		* Exception handler
		*
		* @param {KoattyContext} ctx
		* @returns {*}
		* @memberof Exception
		*/
		handler(ctx: KoattyContext): Promise<ServerResponse>;
		}

		/**
		* Indicates that an decorated class is a "ExceptionHandler".
		* @ExceptionHandler()
		* export class BusinessException extends Exception {
		* constructor(message: string, code: number, status: number) { }
		* handler(ctx: KoattyContext) { ... }
		* }
		*
		* @export
		* @param {string} [identifier] class name
		* @returns {ClassDecorator}
		*/
		export declare function ExceptionHandler(): ClassDecorator;

		export declare class GrpcException extends Error {
		status: number;
		code: number;
		readonly type = "GrpcException";
		/**
		* Creates an instance of Exception.
		* @param {string} message
		* @param {number} [code=1]
		* @param {number} [status]
		* @memberof Exception
		*/
		constructor(message: string, code?: number, status?: number);
		/**
		* Exception handler
		*
		* @protected
		* @returns {*}
		* @memberof Exception
		*/
		handler(ctx: KoattyContext): Promise<void>;
		}

		/**
		* GrpcStatusCode
		*
		* @export
		* @enum {number}
		*/
		export declare enum GrpcStatusCode {
		OK = 0,
		CANCELLED = 1,
		UNKNOWN = 2,
		INVALID_ARGUMENT = 3,
		DEADLINE_EXCEEDED = 4,
		NOT_FOUND = 5,
		ALREADY_EXISTS = 6,
		PERMISSION_DENIED = 7,
		RESOURCE_EXHAUSTED = 8,
		FAILED_PRECONDITION = 9,
		ABORTED = 10,
		OUT_OF_RANGE = 11,
		UNIMPLEMENTED = 12,
		INTERNAL = 13,
		UNAVAILABLE = 14,
		DATA_LOSS = 15,
		UNAUTHENTICATED = 16
		}

		/**
		* GrpcStatusCodeMap
		*/
		export declare const GrpcStatusCodeMap: Map<number, string>;

		/**
		* HttpStatusCode
		*
		* @export
		* @enum {number}
		*/
		export declare enum HttpStatusCode {
		/**
		* The server has received the request headers and the client should proceed to send the request body
		* (in the case of a request for which a body needs to be sent; for example, a POST request).
		* Sending a large request body to a server after a request has been rejected for inappropriate headers would be inefficient.
		* To have a server check the request's headers, a client must send Expect: 100-continue as a header in its initial request
		* and receive a 100 Continue status code in response before sending the body. The response 417 Expectation Failed indicates the request should not be continued.
		*/
		CONTINUE = 100,
		/**
		* The requester has asked the server to switch protocols and the server has agreed to do so.
		*/
		SWITCHING_PROTOCOLS = 101,
		/**
		* A WebDAV request may contain many sub-requests involving file operations, requiring a long time to complete the request.
		* This code indicates that the server has received and is processing the request, but no response is available yet.
		* This prevents the client from timing out and assuming the request was lost.
		*/
		PROCESSING = 102,
		/**
		* Standard response for successful HTTP requests.
		* The actual response will depend on the request method used.
		* In a GET request, the response will contain an entity corresponding to the requested resource.
		* In a POST request, the response will contain an entity describing or containing the result of the action.
		*/
		OK = 200,
		/**
		* The request has been fulfilled, resulting in the creation of a new resource.
		*/
		CREATED = 201,
		/**
		* The request has been accepted for processing, but the processing has not been completed.
		* The request might or might not be eventually acted upon, and may be disallowed when processing occurs.
		*/
		ACCEPTED = 202,
		/**
		* SINCE HTTP/1.1
		* The server is a transforming proxy that received a 200 OK from its origin,
		* but is returning a modified version of the origin's response.
		*/
		NON_AUTHORITATIVE_INFORMATION = 203,
		/**
		* The server successfully processed the request and is not returning any content.
		*/
		NO_CONTENT = 204,
		/**
		* The server successfully processed the request, but is not returning any content.
		* Unlike a 204 response, this response requires that the requester reset the document view.
		*/
		RESET_CONTENT = 205,
		/**
		* The server is delivering only part of the resource (byte serving) due to a range header sent by the client.
		* The range header is used by HTTP clients to enable resuming of interrupted downloads,
		* or split a download into multiple simultaneous streams.
		*/
		PARTIAL_CONTENT = 206,
		/**
		* The message body that follows is an XML message and can contain a number of separate response codes,
		* depending on how many sub-requests were made.
		*/
		MULTI_STATUS = 207,
		/**
		* The members of a DAV binding have already been enumerated in a preceding part of the (multistatus) response,
		* and are not being included again.
		*/
		ALREADY_REPORTED = 208,
		/**
		* The server has fulfilled a request for the resource,
		* and the response is a representation of the result of one or more instance-manipulations applied to the current instance.
		*/
		IM_USED = 226,
		/**
		* Indicates multiple options for the resource from which the client may choose (via agent-driven content negotiation).
		* For example, this code could be used to present multiple video format options,
		* to list files with different filename extensions, or to suggest word-sense disambiguation.
		*/
		MULTIPLE_CHOICES = 300,
		/**
		* This and all future requests should be directed to the given URI.
		*/
		MOVED_PERMANENTLY = 301,
		/**
		* This is an example of industry practice contradicting the standard.
		* The HTTP/1.0 specification (RFC 1945) required the client to perform a temporary redirect
		* (the original describing phrase was "Moved Temporarily"), but popular browsers implemented 302
		* with the functionality of a 303 See Other. Therefore, HTTP/1.1 added status codes 303 and 307
		* to distinguish between the two behaviours. However, some Web applications and frameworks
		* use the 302 status code as if it were the 303.
		*/
		FOUND = 302,
		/**
		* SINCE HTTP/1.1
		* The response to the request can be found under another URI using a GET method.
		* When received in response to a POST (or PUT/DELETE), the client should presume that
		* the server has received the data and should issue a redirect with a separate GET message.
		*/
		SEE_OTHER = 303,
		/**
		* Indicates that the resource has not been modified since the version specified by the request headers If-Modified-Since or If-None-Match.
		* In such case, there is no need to retransmit the resource since the client still has a previously-downloaded copy.
		*/
		NOT_MODIFIED = 304,
		/**
		* SINCE HTTP/1.1
		* The requested resource is available only through a proxy, the address for which is provided in the response.
		* Many HTTP clients (such as Mozilla and Internet Explorer) do not correctly handle responses with this status code, primarily for security reasons.
		*/
		USE_PROXY = 305,
		/**
		* No longer used. Originally meant "Subsequent requests should use the specified proxy."
		*/
		SWITCH_PROXY = 306,
		/**
		* SINCE HTTP/1.1
		* In this case, the request should be repeated with another URI; however, future requests should still use the original URI.
		* In contrast to how 302 was historically implemented, the request method is not allowed to be changed when reissuing the original request.
		* For example, a POST request should be repeated using another POST request.
		*/
		TEMPORARY_REDIRECT = 307,
		/**
		* The request and all future requests should be repeated using another URI.
		* 307 and 308 parallel the behaviors of 302 and 301, but do not allow the HTTP method to change.
		* So, for example, submitting a form to a permanently redirected resource may continue smoothly.
		*/
		PERMANENT_REDIRECT = 308,
		/**
		* The server cannot or will not process the request due to an apparent client error
		* (e.g., malformed request syntax, too large size, invalid request message framing, or deceptive request routing).
		*/
		BAD_REQUEST = 400,
		/**
		* Similar to 403 Forbidden, but specifically for use when authentication is required and has failed or has not yet
		* been provided. The response must include a WWW-Authenticate header field containing a challenge applicable to the
		* requested resource. See Basic access authentication and Digest access authentication. 401 semantically means
		* "unauthenticated",i.e. the user does not have the necessary credentials.
		*/
		UNAUTHORIZED = 401,
		/**
		* Reserved for future use. The original intention was that this code might be used as part of some form of digital
		* cash or micro payment scheme, but that has not happened, and this code is not usually used.
		* Google Developers API uses this status if a particular developer has exceeded the daily limit on requests.
		*/
		PAYMENT_REQUIRED = 402,
		/**
		* The request was valid, but the server is refusing action.
		* The user might not have the necessary permissions for a resource.
		*/
		FORBIDDEN = 403,
		/**
		* The requested resource could not be found but may be available in the future.
		* Subsequent requests by the client are permissible.
		*/
		NOT_FOUND = 404,
		/**
		* A request method is not supported for the requested resource;
		* for example, a GET request on a form that requires data to be presented via POST, or a PUT request on a read-only resource.
		*/
		METHOD_NOT_ALLOWED = 405,
		/**
		* The requested resource is capable of generating only content not acceptable according to the Accept headers sent in the request.
		*/
		NOT_ACCEPTABLE = 406,
		/**
		* The client must first authenticate itself with the proxy.
		*/
		PROXY_AUTHENTICATION_REQUIRED = 407,
		/**
		* The server timed out waiting for the request.
		* According to HTTP specifications:
		* "The client did not produce a request within the time that the server was prepared to wait. The client MAY repeat the request without modifications at any later time."
		*/
		REQUEST_TIMEOUT = 408,
		/**
		* Indicates that the request could not be processed because of conflict in the request,
		* such as an edit conflict between multiple simultaneous updates.
		*/
		CONFLICT = 409,
		/**
		* Indicates that the resource requested is no longer available and will not be available again.
		* This should be used when a resource has been intentionally removed and the resource should be purged.
		* Upon receiving a 410 status code, the client should not request the resource in the future.
		* Clients such as search engines should remove the resource from their indices.
		* Most use cases do not require clients and search engines to purge the resource, and a "404 Not Found" may be used instead.
		*/
		GONE = 410,
		/**
		* The request did not specify the length of its content, which is required by the requested resource.
		*/
		LENGTH_REQUIRED = 411,
		/**
		* The server does not meet one of the preconditions that the requester put on the request.
		*/
		PRECONDITION_FAILED = 412,
		/**
		* The request is larger than the server is willing or able to process. Previously called "Request Entity Too Large".
		*/
		PAYLOAD_TOO_LARGE = 413,
		/**
		* The URI provided was too long for the server to process. Often the result of too much data being encoded as a query-string of a GET request,
		* in which case it should be converted to a POST request.
		* Called "Request-URI Too Long" previously.
		*/
		URI_TOO_LONG = 414,
		/**
		* The request entity has a media type which the server or resource does not support.
		* For example, the client uploads an image as image/svg+xml, but the server requires that images use a different format.
		*/
		UNSUPPORTED_MEDIA_TYPE = 415,
		/**
		* The client has asked for a portion of the file (byte serving), but the server cannot supply that portion.
		* For example, if the client asked for a part of the file that lies beyond the end of the file.
		* Called "Requested Range Not Satisfiable" previously.
		*/
		RANGE_NOT_SATISFIABLE = 416,
		/**
		* The server cannot meet the requirements of the Expect request-header field.
		*/
		EXPECTATION_FAILED = 417,
		/**
		* This code was defined in 1998 as one of the traditional IETF April Fools' jokes, in RFC 2324, Hyper Text Coffee Pot Control Protocol,
		* and is not expected to be implemented by actual HTTP servers. The RFC specifies this code should be returned by
		* teapots requested to brew coffee. This HTTP status is used as an Easter egg in some websites, including Google.com.
		*/
		I_AM_A_TEAPOT = 418,
		/**
		* The request was directed at a server that is not able to produce a response (for example because a connection reuse).
		*/
		MISDIRECTED_REQUEST = 421,
		/**
		* The request was well-formed but was unable to be followed due to semantic errors.
		*/
		UNPROCESSABLE_ENTITY = 422,
		/**
		* The resource that is being accessed is locked.
		*/
		LOCKED = 423,
		/**
		* The request failed due to failure of a previous request (e.g., a PROPPATCH).
		*/
		FAILED_DEPENDENCY = 424,
		/**
		* The client should switch to a different protocol such as TLS/1.0, given in the Upgrade header field.
		*/
		UPGRADE_REQUIRED = 426,
		/**
		* The origin server requires the request to be conditional.
		* Intended to prevent "the 'lost update' problem, where a client
		* GETs a resource's state, modifies it, and PUTs it back to the server,
		* when meanwhile a third party has modified the state on the server, leading to a conflict."
		*/
		PRECONDITION_REQUIRED = 428,
		/**
		* The user has sent too many requests in a given amount of time. Intended for use with rate-limiting schemes.
		*/
		TOO_MANY_REQUESTS = 429,
		/**
		* The server is unwilling to process the request because either an individual header field,
		* or all the header fields collectively, are too large.
		*/
		REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
		/**
		* A server operator has received a legal demand to deny access to a resource or to a set of resources
		* that includes the requested resource. The code 451 was chosen as a reference to the novel Fahrenheit 451.
		*/
		UNAVAILABLE_FOR_LEGAL_REASONS = 451,
		/**
		* A generic error message, given when an unexpected condition was encountered and no more specific message is suitable.
		*/
		INTERNAL_SERVER_ERROR = 500,
		/**
		* The server either does not recognize the request method, or it lacks the ability to fulfill the request.
		* Usually this implies future availability (e.g., a new feature of a web-service API).
		*/
		NOT_IMPLEMENTED = 501,
		/**
		* The server was acting as a gateway or proxy and received an invalid response from the upstream server.
		*/
		BAD_GATEWAY = 502,
		/**
		* The server is currently unavailable (because it is overloaded or down for maintenance).
		* Generally, this is a temporary state.
		*/
		SERVICE_UNAVAILABLE = 503,
		/**
		* The server was acting as a gateway or proxy and did not receive a timely response from the upstream server.
		*/
		GATEWAY_TIMEOUT = 504,
		/**
		* The server does not support the HTTP protocol version used in the request
		*/
		HTTP_VERSION_NOT_SUPPORTED = 505,
		/**
		* Transparent content negotiation for the request results in a circular reference.
		*/
		VARIANT_ALSO_NEGOTIATES = 506,
		/**
		* The server is unable to store the representation needed to complete the request.
		*/
		INSUFFICIENT_STORAGE = 507,
		/**
		* The server detected an infinite loop while processing the request.
		*/
		LOOP_DETECTED = 508,
		/**
		* Further extensions to the request are required for the server to fulfill it.
		*/
		NOT_EXTENDED = 510,
		/**
		* The client needs to authenticate to gain network access.
		* Intended for use by intercepting proxies used to control access to the network (e.g., "captive portals" used
		* to require agreement to Terms of Service before granting full Internet access via a Wi-Fi hotspot).
		*/
		NETWORK_AUTHENTICATION_REQUIRED = 511
		}

		/**
		* HttpStatusCodeMap
		*/
		export declare const HttpStatusCodeMap: Map<number, string>;

		/**
		* Check if the error is a predefined exception
		*
		* @template T
		* @param {(Exception \| T)} err
		* @returns {boolean} {err is Exception}
		*/
		export declare const isException: <T extends {
		message: string;
		code?: number;
		status?: unknown;
		}>(err: Exception \| T) => boolean;

		/**
		* Check is prevent error
		*
		* @param {Error} err
		* @returns {boolean}
		*/
		export declare function isPrevent(err: Error): boolean;

		/**
		* Prevent next process
		*
		* @returns {Promise.reject}
		*/
		export declare function prevent(): Promise<never>;

		/**
		* Convert HttpStatusCode to GrpcStatusCode
		* https://chromium.googlesource.com/external/github.com/grpc/grpc/+/refs/heads/chromium-deps/2016-10-25/doc/http-grpc-status-mapping.md
		* @export
		* @param {HttpStatusCode} code
		* @returns {*} {GrpcStatusCode}
		*/
		export declare function StatusCodeConvert(code: HttpStatusCode): GrpcStatusCode;

		export declare class WsException extends Error {
		status: number;
		code: number;
		readonly type = "WsException";
		/**
		* Creates an instance of Exception.
		* @param {string} message
		* @param {number} [code=1]
		* @param {number} [status]
		* @memberof Exception
		*/
		constructor(message: string, code?: number, status?: number);
		/**
		* Exception handler
		*
		* @protected
		* @returns {*}
		* @memberof Exception
		*/
		handler(ctx: KoattyContext): Promise<any>;
		}

		export { }

799

dist/index.js

		@@ -1,2 +0,37 @@
		"use strict";
		/*!
		* @Author: richen
		* @Date: 2022-02-14 10:34:15
		* @License: BSD (3-Clause)
		* @Copyright (c) - <richenlin(at)gmail.com>
		* @HomePage: https://koatty.org/
		*/
		'use strict';

		Object.defineProperty(exports, '__esModule', { value: true });

		var koatty_container = require('koatty_container');
		var koatty_logger = require('koatty_logger');
		var grpcJs = require('@grpc/grpc-js');
		var Helper = require('koatty_lib');

		function _interopNamespace(e) {
		if (e && e.__esModule) return e;
		var n = Object.create(null);
		if (e) {
		Object.keys(e).forEach(function (k) {
		if (k !== 'default') {
		var d = Object.getOwnPropertyDescriptor(e, k);
		Object.defineProperty(n, k, d.get ? d : {
		enumerable: true,
		get: function () { return e[k]; }
		});
		}
		});
		}
		n["default"] = e;
		return Object.freeze(n);
		}

		var Helper__namespace = /#__PURE__/_interopNamespace(Helper);

		/*
		@@ -6,9 +41,757 @@ * @Description:
		* @Author: richen
		* @Date: 2021-11-17 09:53:49
		* @LastEditTime: 2021-11-19 00:54:14
		* @Date: 2021-11-19 00:53:19
		* @LastEditTime: 2021-11-19 02:30:04
		*/
		Object.defineProperty(exports, "__esModule", { value: true });
		const tslib_1 = require("tslib");
		(0, tslib_1.__exportStar)(require("./exception"), exports);
		(0, tslib_1.__exportStar)(require("./code"), exports);
		//# sourceMappingURL=index.js.map
		/**
		* HttpStatusCode
		*
		* @export
		* @enum {number}
		*/
		exports.HttpStatusCode = void 0;
		(function (HttpStatusCode) {
		/**
		* The server has received the request headers and the client should proceed to send the request body
		* (in the case of a request for which a body needs to be sent; for example, a POST request).
		* Sending a large request body to a server after a request has been rejected for inappropriate headers would be inefficient.
		* To have a server check the request's headers, a client must send Expect: 100-continue as a header in its initial request
		* and receive a 100 Continue status code in response before sending the body. The response 417 Expectation Failed indicates the request should not be continued.
		*/
		HttpStatusCode[HttpStatusCode["CONTINUE"] = 100] = "CONTINUE";
		/**
		* The requester has asked the server to switch protocols and the server has agreed to do so.
		*/
		HttpStatusCode[HttpStatusCode["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
		/**
		* A WebDAV request may contain many sub-requests involving file operations, requiring a long time to complete the request.
		* This code indicates that the server has received and is processing the request, but no response is available yet.
		* This prevents the client from timing out and assuming the request was lost.
		*/
		HttpStatusCode[HttpStatusCode["PROCESSING"] = 102] = "PROCESSING";
		/**
		* Standard response for successful HTTP requests.
		* The actual response will depend on the request method used.
		* In a GET request, the response will contain an entity corresponding to the requested resource.
		* In a POST request, the response will contain an entity describing or containing the result of the action.
		*/
		HttpStatusCode[HttpStatusCode["OK"] = 200] = "OK";
		/**
		* The request has been fulfilled, resulting in the creation of a new resource.
		*/
		HttpStatusCode[HttpStatusCode["CREATED"] = 201] = "CREATED";
		/**
		* The request has been accepted for processing, but the processing has not been completed.
		* The request might or might not be eventually acted upon, and may be disallowed when processing occurs.
		*/
		HttpStatusCode[HttpStatusCode["ACCEPTED"] = 202] = "ACCEPTED";
		/**
		* SINCE HTTP/1.1
		* The server is a transforming proxy that received a 200 OK from its origin,
		* but is returning a modified version of the origin's response.
		*/
		HttpStatusCode[HttpStatusCode["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
		/**
		* The server successfully processed the request and is not returning any content.
		*/
		HttpStatusCode[HttpStatusCode["NO_CONTENT"] = 204] = "NO_CONTENT";
		/**
		* The server successfully processed the request, but is not returning any content.
		* Unlike a 204 response, this response requires that the requester reset the document view.
		*/
		HttpStatusCode[HttpStatusCode["RESET_CONTENT"] = 205] = "RESET_CONTENT";
		/**
		* The server is delivering only part of the resource (byte serving) due to a range header sent by the client.
		* The range header is used by HTTP clients to enable resuming of interrupted downloads,
		* or split a download into multiple simultaneous streams.
		*/
		HttpStatusCode[HttpStatusCode["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
		/**
		* The message body that follows is an XML message and can contain a number of separate response codes,
		* depending on how many sub-requests were made.
		*/
		HttpStatusCode[HttpStatusCode["MULTI_STATUS"] = 207] = "MULTI_STATUS";
		/**
		* The members of a DAV binding have already been enumerated in a preceding part of the (multistatus) response,
		* and are not being included again.
		*/
		HttpStatusCode[HttpStatusCode["ALREADY_REPORTED"] = 208] = "ALREADY_REPORTED";
		/**
		* The server has fulfilled a request for the resource,
		* and the response is a representation of the result of one or more instance-manipulations applied to the current instance.
		*/
		HttpStatusCode[HttpStatusCode["IM_USED"] = 226] = "IM_USED";
		/**
		* Indicates multiple options for the resource from which the client may choose (via agent-driven content negotiation).
		* For example, this code could be used to present multiple video format options,
		* to list files with different filename extensions, or to suggest word-sense disambiguation.
		*/
		HttpStatusCode[HttpStatusCode["MULTIPLE_CHOICES"] = 300] = "MULTIPLE_CHOICES";
		/**
		* This and all future requests should be directed to the given URI.
		*/
		HttpStatusCode[HttpStatusCode["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
		/**
		* This is an example of industry practice contradicting the standard.
		* The HTTP/1.0 specification (RFC 1945) required the client to perform a temporary redirect
		* (the original describing phrase was "Moved Temporarily"), but popular browsers implemented 302
		* with the functionality of a 303 See Other. Therefore, HTTP/1.1 added status codes 303 and 307
		* to distinguish between the two behaviours. However, some Web applications and frameworks
		* use the 302 status code as if it were the 303.
		*/
		HttpStatusCode[HttpStatusCode["FOUND"] = 302] = "FOUND";
		/**
		* SINCE HTTP/1.1
		* The response to the request can be found under another URI using a GET method.
		* When received in response to a POST (or PUT/DELETE), the client should presume that
		* the server has received the data and should issue a redirect with a separate GET message.
		*/
		HttpStatusCode[HttpStatusCode["SEE_OTHER"] = 303] = "SEE_OTHER";
		/**
		* Indicates that the resource has not been modified since the version specified by the request headers If-Modified-Since or If-None-Match.
		* In such case, there is no need to retransmit the resource since the client still has a previously-downloaded copy.
		*/
		HttpStatusCode[HttpStatusCode["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
		/**
		* SINCE HTTP/1.1
		* The requested resource is available only through a proxy, the address for which is provided in the response.
		* Many HTTP clients (such as Mozilla and Internet Explorer) do not correctly handle responses with this status code, primarily for security reasons.
		*/
		HttpStatusCode[HttpStatusCode["USE_PROXY"] = 305] = "USE_PROXY";
		/**
		* No longer used. Originally meant "Subsequent requests should use the specified proxy."
		*/
		HttpStatusCode[HttpStatusCode["SWITCH_PROXY"] = 306] = "SWITCH_PROXY";
		/**
		* SINCE HTTP/1.1
		* In this case, the request should be repeated with another URI; however, future requests should still use the original URI.
		* In contrast to how 302 was historically implemented, the request method is not allowed to be changed when reissuing the original request.
		* For example, a POST request should be repeated using another POST request.
		*/
		HttpStatusCode[HttpStatusCode["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
		/**
		* The request and all future requests should be repeated using another URI.
		* 307 and 308 parallel the behaviors of 302 and 301, but do not allow the HTTP method to change.
		* So, for example, submitting a form to a permanently redirected resource may continue smoothly.
		*/
		HttpStatusCode[HttpStatusCode["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
		/**
		* The server cannot or will not process the request due to an apparent client error
		* (e.g., malformed request syntax, too large size, invalid request message framing, or deceptive request routing).
		*/
		HttpStatusCode[HttpStatusCode["BAD_REQUEST"] = 400] = "BAD_REQUEST";
		/**
		* Similar to 403 Forbidden, but specifically for use when authentication is required and has failed or has not yet
		* been provided. The response must include a WWW-Authenticate header field containing a challenge applicable to the
		* requested resource. See Basic access authentication and Digest access authentication. 401 semantically means
		* "unauthenticated",i.e. the user does not have the necessary credentials.
		*/
		HttpStatusCode[HttpStatusCode["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
		/**
		* Reserved for future use. The original intention was that this code might be used as part of some form of digital
		* cash or micro payment scheme, but that has not happened, and this code is not usually used.
		* Google Developers API uses this status if a particular developer has exceeded the daily limit on requests.
		*/
		HttpStatusCode[HttpStatusCode["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
		/**
		* The request was valid, but the server is refusing action.
		* The user might not have the necessary permissions for a resource.
		*/
		HttpStatusCode[HttpStatusCode["FORBIDDEN"] = 403] = "FORBIDDEN";
		/**
		* The requested resource could not be found but may be available in the future.
		* Subsequent requests by the client are permissible.
		*/
		HttpStatusCode[HttpStatusCode["NOT_FOUND"] = 404] = "NOT_FOUND";
		/**
		* A request method is not supported for the requested resource;
		* for example, a GET request on a form that requires data to be presented via POST, or a PUT request on a read-only resource.
		*/
		HttpStatusCode[HttpStatusCode["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
		/**
		* The requested resource is capable of generating only content not acceptable according to the Accept headers sent in the request.
		*/
		HttpStatusCode[HttpStatusCode["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
		/**
		* The client must first authenticate itself with the proxy.
		*/
		HttpStatusCode[HttpStatusCode["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
		/**
		* The server timed out waiting for the request.
		* According to HTTP specifications:
		* "The client did not produce a request within the time that the server was prepared to wait. The client MAY repeat the request without modifications at any later time."
		*/
		HttpStatusCode[HttpStatusCode["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
		/**
		* Indicates that the request could not be processed because of conflict in the request,
		* such as an edit conflict between multiple simultaneous updates.
		*/
		HttpStatusCode[HttpStatusCode["CONFLICT"] = 409] = "CONFLICT";
		/**
		* Indicates that the resource requested is no longer available and will not be available again.
		* This should be used when a resource has been intentionally removed and the resource should be purged.
		* Upon receiving a 410 status code, the client should not request the resource in the future.
		* Clients such as search engines should remove the resource from their indices.
		* Most use cases do not require clients and search engines to purge the resource, and a "404 Not Found" may be used instead.
		*/
		HttpStatusCode[HttpStatusCode["GONE"] = 410] = "GONE";
		/**
		* The request did not specify the length of its content, which is required by the requested resource.
		*/
		HttpStatusCode[HttpStatusCode["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
		/**
		* The server does not meet one of the preconditions that the requester put on the request.
		*/
		HttpStatusCode[HttpStatusCode["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
		/**
		* The request is larger than the server is willing or able to process. Previously called "Request Entity Too Large".
		*/
		HttpStatusCode[HttpStatusCode["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
		/**
		* The URI provided was too long for the server to process. Often the result of too much data being encoded as a query-string of a GET request,
		* in which case it should be converted to a POST request.
		* Called "Request-URI Too Long" previously.
		*/
		HttpStatusCode[HttpStatusCode["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
		/**
		* The request entity has a media type which the server or resource does not support.
		* For example, the client uploads an image as image/svg+xml, but the server requires that images use a different format.
		*/
		HttpStatusCode[HttpStatusCode["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
		/**
		* The client has asked for a portion of the file (byte serving), but the server cannot supply that portion.
		* For example, if the client asked for a part of the file that lies beyond the end of the file.
		* Called "Requested Range Not Satisfiable" previously.
		*/
		HttpStatusCode[HttpStatusCode["RANGE_NOT_SATISFIABLE"] = 416] = "RANGE_NOT_SATISFIABLE";
		/**
		* The server cannot meet the requirements of the Expect request-header field.
		*/
		HttpStatusCode[HttpStatusCode["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
		/**
		* This code was defined in 1998 as one of the traditional IETF April Fools' jokes, in RFC 2324, Hyper Text Coffee Pot Control Protocol,
		* and is not expected to be implemented by actual HTTP servers. The RFC specifies this code should be returned by
		* teapots requested to brew coffee. This HTTP status is used as an Easter egg in some websites, including Google.com.
		*/
		HttpStatusCode[HttpStatusCode["I_AM_A_TEAPOT"] = 418] = "I_AM_A_TEAPOT";
		/**
		* The request was directed at a server that is not able to produce a response (for example because a connection reuse).
		*/
		HttpStatusCode[HttpStatusCode["MISDIRECTED_REQUEST"] = 421] = "MISDIRECTED_REQUEST";
		/**
		* The request was well-formed but was unable to be followed due to semantic errors.
		*/
		HttpStatusCode[HttpStatusCode["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
		/**
		* The resource that is being accessed is locked.
		*/
		HttpStatusCode[HttpStatusCode["LOCKED"] = 423] = "LOCKED";
		/**
		* The request failed due to failure of a previous request (e.g., a PROPPATCH).
		*/
		HttpStatusCode[HttpStatusCode["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
		/**
		* The client should switch to a different protocol such as TLS/1.0, given in the Upgrade header field.
		*/
		HttpStatusCode[HttpStatusCode["UPGRADE_REQUIRED"] = 426] = "UPGRADE_REQUIRED";
		/**
		* The origin server requires the request to be conditional.
		* Intended to prevent "the 'lost update' problem, where a client
		* GETs a resource's state, modifies it, and PUTs it back to the server,
		* when meanwhile a third party has modified the state on the server, leading to a conflict."
		*/
		HttpStatusCode[HttpStatusCode["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
		/**
		* The user has sent too many requests in a given amount of time. Intended for use with rate-limiting schemes.
		*/
		HttpStatusCode[HttpStatusCode["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
		/**
		* The server is unwilling to process the request because either an individual header field,
		* or all the header fields collectively, are too large.
		*/
		HttpStatusCode[HttpStatusCode["REQUEST_HEADER_FIELDS_TOO_LARGE"] = 431] = "REQUEST_HEADER_FIELDS_TOO_LARGE";
		/**
		* A server operator has received a legal demand to deny access to a resource or to a set of resources
		* that includes the requested resource. The code 451 was chosen as a reference to the novel Fahrenheit 451.
		*/
		HttpStatusCode[HttpStatusCode["UNAVAILABLE_FOR_LEGAL_REASONS"] = 451] = "UNAVAILABLE_FOR_LEGAL_REASONS";
		/**
		* A generic error message, given when an unexpected condition was encountered and no more specific message is suitable.
		*/
		HttpStatusCode[HttpStatusCode["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
		/**
		* The server either does not recognize the request method, or it lacks the ability to fulfill the request.
		* Usually this implies future availability (e.g., a new feature of a web-service API).
		*/
		HttpStatusCode[HttpStatusCode["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
		/**
		* The server was acting as a gateway or proxy and received an invalid response from the upstream server.
		*/
		HttpStatusCode[HttpStatusCode["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
		/**
		* The server is currently unavailable (because it is overloaded or down for maintenance).
		* Generally, this is a temporary state.
		*/
		HttpStatusCode[HttpStatusCode["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
		/**
		* The server was acting as a gateway or proxy and did not receive a timely response from the upstream server.
		*/
		HttpStatusCode[HttpStatusCode["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
		/**
		* The server does not support the HTTP protocol version used in the request
		*/
		HttpStatusCode[HttpStatusCode["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
		/**
		* Transparent content negotiation for the request results in a circular reference.
		*/
		HttpStatusCode[HttpStatusCode["VARIANT_ALSO_NEGOTIATES"] = 506] = "VARIANT_ALSO_NEGOTIATES";
		/**
		* The server is unable to store the representation needed to complete the request.
		*/
		HttpStatusCode[HttpStatusCode["INSUFFICIENT_STORAGE"] = 507] = "INSUFFICIENT_STORAGE";
		/**
		* The server detected an infinite loop while processing the request.
		*/
		HttpStatusCode[HttpStatusCode["LOOP_DETECTED"] = 508] = "LOOP_DETECTED";
		/**
		* Further extensions to the request are required for the server to fulfill it.
		*/
		HttpStatusCode[HttpStatusCode["NOT_EXTENDED"] = 510] = "NOT_EXTENDED";
		/**
		* The client needs to authenticate to gain network access.
		* Intended for use by intercepting proxies used to control access to the network (e.g., "captive portals" used
		* to require agreement to Terms of Service before granting full Internet access via a Wi-Fi hotspot).
		*/
		HttpStatusCode[HttpStatusCode["NETWORK_AUTHENTICATION_REQUIRED"] = 511] = "NETWORK_AUTHENTICATION_REQUIRED";
		})(exports.HttpStatusCode \|\| (exports.HttpStatusCode = {}));
		/**
		* HttpStatusCodeMap
		*/
		const HttpStatusCodeMap = new Map([
		[100, "CONTINUE"],
		[101, "SWITCHING_PROTOCOLS"],
		[102, "PROCESSING"],
		[200, "OK"],
		[201, "CREATED"],
		[202, "ACCEPTED"],
		[203, "NON_AUTHORITATIVE_INFORMATION"],
		[204, "NO_CONTENT"],
		[205, "RESET_CONTENT"],
		[206, "PARTIAL_CONTENT"],
		[207, "MULTI_STATUS"],
		[208, "ALREADY_REPORTED"],
		[226, "IM_USED"],
		[300, "MULTIPLE_CHOICES"],
		[301, "MOVED_PERMANENTLY"],
		[302, "FOUND"],
		[303, "SEE_OTHER"],
		[304, "NOT_MODIFIED"],
		[305, "USE_PROXY"],
		[306, "SWITCH_PROXY"],
		[307, "TEMPORARY_REDIRECT"],
		[308, "PERMANENT_REDIRECT"],
		[400, "BAD_REQUEST"],
		[401, "UNAUTHORIZED"],
		[402, "PAYMENT_REQUIRED"],
		[403, "FORBIDDEN"],
		[404, "NOT_FOUND"],
		[405, "METHOD_NOT_ALLOWED"],
		[406, "NOT_ACCEPTABLE"],
		[407, "PROXY_AUTHENTICATION_REQUIRED"],
		[408, "REQUEST_TIMEOUT"],
		[409, "CONFLICT"],
		[410, "GONE"],
		[411, "LENGTH_REQUIRED"],
		[412, "PRECONDITION_FAILED"],
		[413, "PAYLOAD_TOO_LARGE"],
		[414, "URI_TOO_LONG"],
		[415, "UNSUPPORTED_MEDIA_TYPE"],
		[416, "RANGE_NOT_SATISFIABLE"],
		[417, "EXPECTATION_FAILED"],
		[418, "I_AM_A_TEAPOT"],
		[421, "MISDIRECTED_REQUEST"],
		[422, "UNPROCESSABLE_ENTITY"],
		[423, "LOCKED"],
		[424, "FAILED_DEPENDENCY"],
		[426, "UPGRADE_REQUIRED"],
		[428, "PRECONDITION_REQUIRED"],
		[429, "TOO_MANY_REQUESTS"],
		[431, "REQUEST_HEADER_FIELDS_TOO_LARGE"],
		[451, "UNAVAILABLE_FOR_LEGAL_REASONS"],
		[500, "INTERNAL_SERVER_ERROR"],
		[501, "NOT_IMPLEMENTED"],
		[502, "BAD_GATEWAY"],
		[503, "SERVICE_UNAVAILABLE"],
		[504, "GATEWAY_TIMEOUT"],
		[505, "HTTP_VERSION_NOT_SUPPORTED"],
		[506, "VARIANT_ALSO_NEGOTIATES"],
		[507, "INSUFFICIENT_STORAGE"],
		[508, "LOOP_DETECTED"],
		[510, "NOT_EXTENDED"],
		[511, "NETWORK_AUTHENTICATION_REQUIRED"],
		]);
		/**
		* GrpcStatusCode
		*
		* @export
		* @enum {number}
		*/
		exports.GrpcStatusCode = void 0;
		(function (GrpcStatusCode) {
		GrpcStatusCode[GrpcStatusCode["OK"] = 0] = "OK";
		GrpcStatusCode[GrpcStatusCode["CANCELLED"] = 1] = "CANCELLED";
		GrpcStatusCode[GrpcStatusCode["UNKNOWN"] = 2] = "UNKNOWN";
		GrpcStatusCode[GrpcStatusCode["INVALID_ARGUMENT"] = 3] = "INVALID_ARGUMENT";
		GrpcStatusCode[GrpcStatusCode["DEADLINE_EXCEEDED"] = 4] = "DEADLINE_EXCEEDED";
		GrpcStatusCode[GrpcStatusCode["NOT_FOUND"] = 5] = "NOT_FOUND";
		GrpcStatusCode[GrpcStatusCode["ALREADY_EXISTS"] = 6] = "ALREADY_EXISTS";
		GrpcStatusCode[GrpcStatusCode["PERMISSION_DENIED"] = 7] = "PERMISSION_DENIED";
		GrpcStatusCode[GrpcStatusCode["RESOURCE_EXHAUSTED"] = 8] = "RESOURCE_EXHAUSTED";
		GrpcStatusCode[GrpcStatusCode["FAILED_PRECONDITION"] = 9] = "FAILED_PRECONDITION";
		GrpcStatusCode[GrpcStatusCode["ABORTED"] = 10] = "ABORTED";
		GrpcStatusCode[GrpcStatusCode["OUT_OF_RANGE"] = 11] = "OUT_OF_RANGE";
		GrpcStatusCode[GrpcStatusCode["UNIMPLEMENTED"] = 12] = "UNIMPLEMENTED";
		GrpcStatusCode[GrpcStatusCode["INTERNAL"] = 13] = "INTERNAL";
		GrpcStatusCode[GrpcStatusCode["UNAVAILABLE"] = 14] = "UNAVAILABLE";
		GrpcStatusCode[GrpcStatusCode["DATA_LOSS"] = 15] = "DATA_LOSS";
		GrpcStatusCode[GrpcStatusCode["UNAUTHENTICATED"] = 16] = "UNAUTHENTICATED";
		})(exports.GrpcStatusCode \|\| (exports.GrpcStatusCode = {}));
		/**
		* GrpcStatusCodeMap
		*/
		const GrpcStatusCodeMap = new Map([
		[0, "OK"],
		[1, "CANCELLED"],
		[2, "UNKNOWN"],
		[3, "INVALID_ARGUMENT"],
		[4, "DEADLINE_EXCEEDED"],
		[5, "NOT_FOUND"],
		[6, "ALREADY_EXISTS"],
		[7, "PERMISSION_DENIED"],
		[8, "RESOURCE_EXHAUSTED"],
		[9, "FAILED_PRECONDITION"],
		[10, "ABORTED"],
		[11, "OUT_OF_RANGE"],
		[12, "UNIMPLEMENTED"],
		[13, "INTERNAL"],
		[14, "UNAVAILABLE"],
		[15, "DATA_LOSS"],
		[14, "UNAUTHENTICATED"],
		]);
		/**
		* Convert HttpStatusCode to GrpcStatusCode
		* https://chromium.googlesource.com/external/github.com/grpc/grpc/+/refs/heads/chromium-deps/2016-10-25/doc/http-grpc-status-mapping.md
		* @export
		* @param {HttpStatusCode} code
		* @returns {*} {GrpcStatusCode}
		*/
		function StatusCodeConvert(code) {
		switch (code) {
		case 200: //HttpStatusCode.OK:
		return 0; //GrpcStatusCode.OK;
		case 304: //HttpStatusCode.NOT_MODIFIED:
		return 1; //GrpcStatusCode.CANCELLED;
		case 400: //HttpStatusCode.BAD_REQUEST:
		return 3; //GrpcStatusCode.INVALID_ARGUMENT;
		case 408: //HttpStatusCode.REQUEST_TIMEOUT:
		return 4; //GrpcStatusCode.DEADLINE_EXCEEDED;
		case 404: //HttpStatusCode.NOT_FOUND:
		return 5; //GrpcStatusCode.NOT_FOUND;
		case 409: //HttpStatusCode.CONFLICT:
		return 6; //GrpcStatusCode.ALREADY_EXISTS;
		case 403: //HttpStatusCode.FORBIDDEN:
		return 7; //GrpcStatusCode.PERMISSION_DENIED;
		case 429: //HttpStatusCode.TOO_MANY_REQUESTS:
		return 8; //GrpcStatusCode.RESOURCE_EXHAUSTED;
		case 412: //HttpStatusCode.PRECONDITION_FAILED:
		return 9; //GrpcStatusCode.FAILED_PRECONDITION;
		case 421: //HttpStatusCode.MISDIRECTED_REQUEST:
		return 10; //GrpcStatusCode.ABORTED;
		case 416: //HttpStatusCode.RANGE_NOT_SATISFIABLE:
		return 11; //GrpcStatusCode.OUT_OF_RANGE;
		case 501: //HttpStatusCode.NOT_IMPLEMENTED:
		return 12; //GrpcStatusCode.UNIMPLEMENTED;
		case 500: //HttpStatusCode.INTERNAL_SERVER_ERROR:
		return 13; //GrpcStatusCode.INTERNAL;
		case 503: //HttpStatusCode.SERVICE_UNAVAILABLE:
		return 14; //GrpcStatusCode.UNAVAILABLE;
		case 410: //HttpStatusCode.GONE:
		return 15; //GrpcStatusCode.DATA_LOSS;
		case 401: //HttpStatusCode.UNAUTHORIZED:
		return 16; //GrpcStatusCode.UNAUTHENTICATED;
		default:
		return 2; //GrpcStatusCode.UNKNOWN;
		}
		}

		/**
		* @ author: richen
		* @ copyright: Copyright (c) - <richenlin(at)gmail.com>
		* @ license: BSD (3-Clause)
		* @ version: 2020-12-15 11:49:15
		*/
		/**
		* Predefined runtime exception
		*
		* @export
		* @class HttpError
		* @extends {Error}
		*/
		class Exception extends Error {
		/**
		* Creates an instance of Exception.
		* @param {string} message
		* @param {number} [code=1]
		* @param {number} [status]
		* @memberof Exception
		*/
		constructor(message, code = 1, status) {
		super(message);
		this.type = "Exception";
		this.status = status \|\| 500;
		this.code = code \|\| 1;
		}
		/**
		* Exception handler
		*
		* @param {KoattyContext} ctx
		* @returns {*}
		* @memberof Exception
		*/
		async handler(ctx) {
		try {
		let body = ctx.body;
		if (!body) {
		body = this.message \|\| ctx.message \|\| "";
		}
		ctx.status = ctx.status \|\| 500;
		if (HttpStatusCodeMap.has(this.status)) {
		ctx.status = this.status;
		}
		this.message = body;
		return responseBody$1(ctx, this);
		}
		catch (error) {
		koatty_logger.DefaultLogger.Error(error);
		return null;
		}
		}
		}
		/**
		*
		*
		* @param {KoattyContext} ctx
		* @param {Exception} err
		* @returns {*}
		*/
		function responseBody$1(ctx, err) {
		let contentType = 'application/json';
		if (ctx.encoding !== false) {
		contentType = `${contentType}; charset=${ctx.encoding}`;
		}
		ctx.type = contentType;
		const { code, message } = err;
		const body = `{"code":${code \|\| 1},"message":"${message !== null && message !== void 0 ? message : ""}"}`;
		ctx.set("Content-Length", `${Buffer.byteLength(body)}`);
		return ctx.res.end(body);
		}

		/*
		* @Description:
		* @Usage:
		* @Author: richen
		* @Date: 2022-01-25 10:32:15
		* @LastEditTime: 2022-02-11 10:21:06
		*/
		/**
		* Indicates that an decorated class is a "ExceptionHandler".
		* @ExceptionHandler()
		* export class BusinessException extends Exception {
		* constructor(message: string, code: number, status: number) { }
		* handler(ctx: KoattyContext) { ... }
		* }
		*
		* @export
		* @param {string} [identifier] class name
		* @returns {ClassDecorator}
		*/
		function ExceptionHandler() {
		return (target) => {
		const identifier = koatty_container.IOCContainer.getIdentifier(target);
		// if (identifier === "Exception") {
		// throw new Error("class name cannot be `Exception`");
		// }
		// if (!identifier.endsWith("Exception")) {
		// throw Error("class name must end with 'Exception'");
		// }
		// if (!target.prototype.type) {
		// throw new Error("class's property 'type' must be set");
		// }
		if (!(target.prototype instanceof Exception)) {
		throw new Error(`class ${identifier} does not inherit from class 'Exception'`);
		}
		koatty_container.IOCContainer.saveClass("COMPONENT", target, "ExceptionHandler");
		};
		}

		/*
		* @Description:
		* @Usage:
		* @Author: richen
		* @Date: 2022-02-10 17:39:54
		* @LastEditTime: 2022-02-11 10:36:27
		*/
		class GrpcException extends Error {
		/**
		* Creates an instance of Exception.
		* @param {string} message
		* @param {number} [code=1]
		* @param {number} [status]
		* @memberof Exception
		*/
		constructor(message, code = 2, status) {
		super(message);
		this.type = "GrpcException";
		this.status = status \|\| 500;
		this.code = code \|\| 2;
		}
		/**
		* Exception handler
		*
		* @protected
		* @returns {*}
		* @memberof Exception
		*/
		async handler(ctx) {
		var _a;
		let errObj;
		try {
		// http status convert to grpc status
		const status = this.status \|\| ctx.status;
		if (!this.code && HttpStatusCodeMap.has(status)) {
		this.code = StatusCodeConvert(status);
		}
		this.code = (_a = this.code) !== null && _a !== void 0 ? _a : 2;
		this.message = this.message \|\| GrpcStatusCodeMap.get(this.code) \|\| "";
		if (this.message !== "") {
		errObj = new grpcJs.StatusBuilder().withCode(this.code).withDetails(this.message).build();
		}
		else {
		errObj = new grpcJs.StatusBuilder().withCode(this.code).build();
		}
		ctx.rpc.callback(errObj, null);
		return;
		}
		catch (error) {
		koatty_logger.DefaultLogger.Error(error);
		ctx.rpc.callback(new grpcJs.StatusBuilder().withCode(2).build(), null);
		return;
		}
		}
		}

		/*
		* @Description:
		* @Usage:
		* @Author: richen
		* @Date: 2022-02-10 18:16:36
		* @LastEditTime: 2022-02-11 10:36:34
		*/
		class WsException extends Error {
		/**
		* Creates an instance of Exception.
		* @param {string} message
		* @param {number} [code=1]
		* @param {number} [status]
		* @memberof Exception
		*/
		constructor(message, code = 1, status) {
		super(message);
		this.type = "WsException";
		this.status = status \|\| 500;
		this.code = code \|\| 1;
		}
		/**
		* Exception handler
		*
		* @protected
		* @returns {*}
		* @memberof Exception
		*/
		async handler(ctx) {
		try {
		let body = ctx.body;
		if (!body) {
		body = this.message \|\| ctx.message \|\| "";
		}
		ctx.status = ctx.status \|\| 500;
		if (HttpStatusCodeMap.has(this.status)) {
		ctx.status = this.status;
		}
		this.message = body;
		return responseBody(ctx, this);
		}
		catch (error) {
		koatty_logger.DefaultLogger.Error(error);
		return null;
		}
		}
		}
		/**
		*
		*
		* @param {KoattyContext} ctx
		* @param {WsException} err
		* @returns {*}
		*/
		function responseBody(ctx, err) {
		var _a;
		ctx.status = (_a = err.status) !== null && _a !== void 0 ? _a : (ctx.status \|\| 500);
		ctx.websocket.emit('error');
		return null;
		}

		/*
		* @Description:
		* @Usage:
		* @Author: richen
		* @Date: 2022-02-10 17:40:55
		* @LastEditTime: 2022-02-10 18:48:57
		*/
		const PREVENT_NEXT_PROCESS = 'PREVENT_NEXT_PROCESS';
		/**
		* Prevent next process
		*
		* @returns {Promise.reject}
		*/
		function prevent() {
		return Promise.reject(new Error(PREVENT_NEXT_PROCESS));
		}
		/**
		* Check is prevent error
		*
		* @param {Error} err
		* @returns {boolean}
		*/
		function isPrevent(err) {
		return Helper__namespace.isError(err) && err.message === PREVENT_NEXT_PROCESS;
		}
		/**
		* Check if the error is a predefined exception
		*
		* @template T
		* @param {(Exception \| T)} err
		* @returns {boolean} {err is Exception}
		*/
		const isException = (err) => err instanceof Exception \|\|
		!!(err && Object.hasOwnProperty.call(err, "handler") && Object.hasOwnProperty.call(err, "code"));

		exports.Exception = Exception;
		exports.ExceptionHandler = ExceptionHandler;
		exports.GrpcException = GrpcException;
		exports.GrpcStatusCodeMap = GrpcStatusCodeMap;
		exports.HttpStatusCodeMap = HttpStatusCodeMap;
		exports.StatusCodeConvert = StatusCodeConvert;
		exports.WsException = WsException;
		exports.isException = isException;
		exports.isPrevent = isPrevent;
		exports.prevent = prevent;

package.json

		{
		"name": "koatty_exception",
		"version": "1.0.6",
		"version": "1.1.1-0",
		"description": "Exception handler for koatty.",
		"scripts": {
		"build": "del-cli --force dist && tsc",
		"build": "npm run build:js && npm run build:dts && npm run build:doc && npm run build:cp",
		"build:cp": "node scripts/postBuild && copyfiles package.json LICENSE README.md dist/",
		"build:js": "del-cli --force dist && npx rollup -c",
		"build:doc": "del-cli --force docs/api && npx api-documenter markdown --input temp --output docs/api",
		"build:dts": "del-cli --force temp && npx tsc && npx api-extractor run --local --verbose",
		"eslint": "eslint --ext .ts,.js ./",
		"prepublishOnly": "npm test && npm run build",
		"prerelease": "npm test && npm run build",
		"release": "standard-version",
		"release:pre": "npm run release -- --prerelease",
		"release:major": "npm run release -- --release-as major",
		"release:minor": "npm run release -- --release-as minor",
		"pub": "git push --follow-tags origin && npm publish",
		"test": "npm run eslint && jest --passWithNoTests",
		@@ -15,2 +24,6 @@ "test:cov": "jest --collectCoverage --detectOpenHandles",
		"main": "./dist/index.js",
		"exports": {
		"require": "./dist/index.js",
		"import": "./dist/index.mjs"
		},
		"repository": {
		@@ -38,3 +51,3 @@ "type": "git",
		},
		"license": "MIT",
		"license": "BSD-3-Clause",
		"bugs": {
		@@ -51,16 +64,24 @@ "url": "https://github.com/koatty/koatty_exception/issues"
		"devDependencies": {
		"@commitlint/cli": "^12.x.x",
		"@commitlint/config-conventional": "^12.x.x",
		"@types/cls-hooked": "^4.x.x",
		"@grpc/grpc-js": "^1.x.x",
		"@microsoft/api-documenter": "^7.x.x",
		"@microsoft/api-extractor": "^7.x.x",
		"@rollup/plugin-json": "^4.x.x",
		"@types/jest": "^27.x.x",
		"@types/koa": "^2.x.x",
		"@types/node": "^14.x.x",
		"@typescript-eslint/eslint-plugin": "^4.x.x",
		"@typescript-eslint/parser": "^4.x.x",
		"@types/node": "^16.x.x",
		"@types/ws": "^8.x.x",
		"@typescript-eslint/eslint-plugin": "^5.x.x",
		"@typescript-eslint/parser": "^5.x.x",
		"commitlint": "^15.x.x",
		"commitlint-config-gitmoji": "^2.x.x",
		"conventional-changelog-cli": "^2.x.x",
		"del-cli": "^3.x.x",
		"eslint": "^7.x.x",
		"eslint-plugin-jest": "^24.x.x",
		"husky": "^6.x.x",
		"copyfiles": "^2.x.x",
		"del-cli": "^4.x.x",
		"eslint": "^8.x.x",
		"eslint-plugin-jest": "^25.x.x",
		"husky": "^7.x.x",
		"jest": "^27.x.x",
		"jest-html-reporters": "^2.x.x",
		"rollup": "^2.x.x",
		"rollup-plugin-typescript2": "^0.x.x",
		"standard-version": "^9.x.x",
		@@ -72,9 +93,11 @@ "ts-jest": "^27.x.x",
		"dependencies": {
		"koatty_lib": "^1.x.x"
		"koatty_core": "^1.x.x",
		"koatty_lib": "^1.x.x",
		"koatty_logger": "^1.x.x"
		},
		"husky": {
		"hooks": {
		"commit-msg": "commitlint -E HUSKY_GIT_PARAMS"
		}
		"peerDependencies": {
		"koatty_core": "^1.x.x",
		"koatty_lib": "^1.x.x",
		"koatty_logger": "^1.x.x"
		}
		}

.eslintignore

.eslintrc.js

commitlint.config.js

dist/code.d.ts

dist/code.js

dist/code.js.map

dist/exception.d.ts

dist/exception.js

dist/exception.js.map

dist/index.js.map

jest_html_reporters.html

jest.config.js

tsconfig.json

LICENSE

Sorry, the diff of this file is not supported yet

koatty_exception - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics

Dependency changes