@resin/pinejs
Version:
Pine.js is a sophisticated rules-driven API engine that enables you to define rules in a structured subset of English. Those rules are used in order for Pine.js to generate a database schema and the associated [OData](http://www.odata.org/) API. This make
266 lines • 7.78 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const TypedError = require("typed-error");
class PermissionError extends TypedError {
}
exports.PermissionError = PermissionError;
class PermissionParsingError extends TypedError {
}
exports.PermissionParsingError = PermissionParsingError;
class UnsupportedMethodError extends TypedError {
}
exports.UnsupportedMethodError = UnsupportedMethodError;
class SqlCompilationError extends TypedError {
}
exports.SqlCompilationError = SqlCompilationError;
class SbvrValidationError extends TypedError {
}
exports.SbvrValidationError = SbvrValidationError;
class TranslationError extends TypedError {
}
exports.TranslationError = TranslationError;
class ParsingError extends TypedError {
}
exports.ParsingError = ParsingError;
class HttpError extends TypedError {
constructor(status, error = '', body) {
super(error);
this.status = status;
this.body = body;
}
getResponseBody() {
return this.body !== undefined ?
this.body :
this.message;
}
}
exports.HttpError = HttpError;
class BadRequestError extends HttpError {
constructor(error, body) {
super(400, error, body);
}
}
exports.BadRequestError = BadRequestError;
class UnauthorizedError extends HttpError {
constructor(error, body) {
super(401, error, body);
}
}
exports.UnauthorizedError = UnauthorizedError;
class PaymentRequired extends HttpError {
constructor(error, body) {
super(402, error, body);
}
}
exports.PaymentRequired = PaymentRequired;
class ForbiddenError extends HttpError {
constructor(error, body) {
super(403, error, body);
}
}
exports.ForbiddenError = ForbiddenError;
class NotFoundError extends HttpError {
constructor(error, body) {
super(404, error, body);
}
}
exports.NotFoundError = NotFoundError;
class MethodNotAllowedError extends HttpError {
constructor(error, body) {
super(405, error, body);
}
}
exports.MethodNotAllowedError = MethodNotAllowedError;
class NotAcceptableError extends HttpError {
constructor(error, body) {
super(406, error, body);
}
}
exports.NotAcceptableError = NotAcceptableError;
class ProxyAuthenticationRequiredError extends HttpError {
constructor(error, body) {
super(407, error, body);
}
}
exports.ProxyAuthenticationRequiredError = ProxyAuthenticationRequiredError;
class RequestTimeoutError extends HttpError {
constructor(error, body) {
super(408, error, body);
}
}
exports.RequestTimeoutError = RequestTimeoutError;
class ConflictError extends HttpError {
constructor(error, body) {
super(409, error, body);
}
}
exports.ConflictError = ConflictError;
class GoneError extends HttpError {
constructor(error, body) {
super(410, error, body);
}
}
exports.GoneError = GoneError;
class LengthRequiredError extends HttpError {
constructor(error, body) {
super(411, error, body);
}
}
exports.LengthRequiredError = LengthRequiredError;
class PreconditionFailedError extends HttpError {
constructor(error, body) {
super(412, error, body);
}
}
exports.PreconditionFailedError = PreconditionFailedError;
class PayloadTooLargeError extends HttpError {
constructor(error, body) {
super(413, error, body);
}
}
exports.PayloadTooLargeError = PayloadTooLargeError;
class URITooLongError extends HttpError {
constructor(error, body) {
super(414, error, body);
}
}
exports.URITooLongError = URITooLongError;
class UnsupportedMediaTypeError extends HttpError {
constructor(error, body) {
super(415, error, body);
}
}
exports.UnsupportedMediaTypeError = UnsupportedMediaTypeError;
class RequestedRangeNotSatisfiableError extends HttpError {
constructor(error, body) {
super(416, error, body);
}
}
exports.RequestedRangeNotSatisfiableError = RequestedRangeNotSatisfiableError;
class ExpectationFailedError extends HttpError {
constructor(error, body) {
super(417, error, body);
}
}
exports.ExpectationFailedError = ExpectationFailedError;
class MisdirectedRequestError extends HttpError {
constructor(error, body) {
super(421, error, body);
}
}
exports.MisdirectedRequestError = MisdirectedRequestError;
class UnprocessableEntityError extends HttpError {
constructor(error, body) {
super(422, error, body);
}
}
exports.UnprocessableEntityError = UnprocessableEntityError;
class LockedError extends HttpError {
constructor(error, body) {
super(423, error, body);
}
}
exports.LockedError = LockedError;
class FailedDependencyError extends HttpError {
constructor(error, body) {
super(424, error, body);
}
}
exports.FailedDependencyError = FailedDependencyError;
class UpgradeRequiredError extends HttpError {
constructor(error, body) {
super(426, error, body);
}
}
exports.UpgradeRequiredError = UpgradeRequiredError;
class PreconditionRequiredError extends HttpError {
constructor(error, body) {
super(428, error, body);
}
}
exports.PreconditionRequiredError = PreconditionRequiredError;
class TooManyRequestsError extends HttpError {
constructor(error, body) {
super(429, error, body);
}
}
exports.TooManyRequestsError = TooManyRequestsError;
class RequestHeaderFieldsTooLargeError extends HttpError {
constructor(error, body) {
super(431, error, body);
}
}
exports.RequestHeaderFieldsTooLargeError = RequestHeaderFieldsTooLargeError;
class UnavailableForLegalReasonsError extends HttpError {
constructor(error, body) {
super(451, error, body);
}
}
exports.UnavailableForLegalReasonsError = UnavailableForLegalReasonsError;
class InternalRequestError extends HttpError {
constructor(error, body) {
super(500, error, body);
}
}
exports.InternalRequestError = InternalRequestError;
class NotImplementedError extends HttpError {
constructor(error, body) {
super(501, error, body);
}
}
exports.NotImplementedError = NotImplementedError;
class BadGatewayError extends HttpError {
constructor(error, body) {
super(502, error, body);
}
}
exports.BadGatewayError = BadGatewayError;
class ServiceUnavailableError extends HttpError {
constructor(error, body) {
super(503, error, body);
}
}
exports.ServiceUnavailableError = ServiceUnavailableError;
class GatewayTimeoutError extends HttpError {
constructor(error, body) {
super(504, error, body);
}
}
exports.GatewayTimeoutError = GatewayTimeoutError;
class HTTPVersionNotSupportedError extends HttpError {
constructor(error, body) {
super(505, error, body);
}
}
exports.HTTPVersionNotSupportedError = HTTPVersionNotSupportedError;
class VariantAlsoNegotiatesError extends HttpError {
constructor(error, body) {
super(506, error, body);
}
}
exports.VariantAlsoNegotiatesError = VariantAlsoNegotiatesError;
class InsufficientStorageError extends HttpError {
constructor(error, body) {
super(507, error, body);
}
}
exports.InsufficientStorageError = InsufficientStorageError;
class LoopDetectedError extends HttpError {
constructor(error, body) {
super(508, error, body);
}
}
exports.LoopDetectedError = LoopDetectedError;
class NotExtendedError extends HttpError {
constructor(error, body) {
super(510, error, body);
}
}
exports.NotExtendedError = NotExtendedError;
class NetworkAuthenticationRequiredError extends HttpError {
constructor(error, body) {
super(511, error, body);
}
}
exports.NetworkAuthenticationRequiredError = NetworkAuthenticationRequiredError;
//# sourceMappingURL=errors.js.map