@feathersjs/errors

  • Version 5.0.25
  • Published
  • 68.8 kB
  • No dependencies
  • MIT license

Install

npm i @feathersjs/errors
yarn add @feathersjs/errors
pnpm add @feathersjs/errors

Overview

Common error types for Feathers apps

Index

Variables

variable errors

const errors: {
FeathersError: typeof FeathersError;
BadRequest: typeof BadRequest;
NotAuthenticated: typeof NotAuthenticated;
PaymentError: typeof PaymentError;
Forbidden: typeof Forbidden;
NotFound: typeof NotFound;
MethodNotAllowed: typeof MethodNotAllowed;
NotAcceptable: typeof NotAcceptable;
Timeout: typeof Timeout;
Conflict: typeof Conflict;
LengthRequired: typeof LengthRequired;
Unprocessable: typeof Unprocessable;
TooManyRequests: typeof TooManyRequests;
GeneralError: typeof GeneralError;
NotImplemented: typeof NotImplemented;
BadGateway: typeof BadGateway;
Unavailable: typeof Unavailable;
400: typeof BadRequest;
401: typeof NotAuthenticated;
402: typeof PaymentError;
403: typeof Forbidden;
404: typeof NotFound;
405: typeof MethodNotAllowed;
406: typeof NotAcceptable;
408: typeof Timeout;
409: typeof Conflict;
410: typeof Gone;
411: typeof LengthRequired;
422: typeof Unprocessable;
429: typeof TooManyRequests;
500: typeof GeneralError;
501: typeof NotImplemented;
502: typeof BadGateway;
503: typeof Unavailable;
};

    Functions

    function convert

    convert: (error: any) => any;

      Classes

      class BadGateway

      class BadGateway extends FeathersError {}

        constructor

        constructor(message?: ErrorMessage, data?: any);

          class BadRequest

          class BadRequest extends FeathersError {}

            constructor

            constructor(message?: ErrorMessage, data?: any);

              class Conflict

              class Conflict extends FeathersError {}

                constructor

                constructor(message?: ErrorMessage, data?: any);

                  class FeathersError

                  class FeathersError extends Error {}

                    constructor

                    constructor(
                    err: ErrorMessage,
                    name: string,
                    code: number,
                    className: string,
                    _data: any
                    );

                      property className

                      readonly className: string;

                        property code

                        readonly code: number;

                          property data

                          readonly data: any;

                            property errors

                            readonly errors: any;

                              property type

                              readonly type: string;

                                method toJSON

                                toJSON: () => FeathersErrorJSON;

                                  class Forbidden

                                  class Forbidden extends FeathersError {}

                                    constructor

                                    constructor(message?: ErrorMessage, data?: any);

                                      class GeneralError

                                      class GeneralError extends FeathersError {}

                                        constructor

                                        constructor(message?: ErrorMessage, data?: any);

                                          class Gone

                                          class Gone extends FeathersError {}

                                            constructor

                                            constructor(message?: ErrorMessage, data?: any);

                                              class LengthRequired

                                              class LengthRequired extends FeathersError {}

                                                constructor

                                                constructor(message?: ErrorMessage, data?: any);

                                                  class MethodNotAllowed

                                                  class MethodNotAllowed extends FeathersError {}

                                                    constructor

                                                    constructor(message?: ErrorMessage, data?: any);

                                                      class NotAcceptable

                                                      class NotAcceptable extends FeathersError {}

                                                        constructor

                                                        constructor(message?: ErrorMessage, data?: any);

                                                          class NotAuthenticated

                                                          class NotAuthenticated extends FeathersError {}

                                                            constructor

                                                            constructor(message?: ErrorMessage, data?: any);

                                                              class NotFound

                                                              class NotFound extends FeathersError {}

                                                                constructor

                                                                constructor(message?: ErrorMessage, data?: any);

                                                                  class NotImplemented

                                                                  class NotImplemented extends FeathersError {}

                                                                    constructor

                                                                    constructor(message?: ErrorMessage, data?: any);

                                                                      class PaymentError

                                                                      class PaymentError extends FeathersError {}

                                                                        constructor

                                                                        constructor(message?: ErrorMessage, data?: any);

                                                                          class Timeout

                                                                          class Timeout extends FeathersError {}

                                                                            constructor

                                                                            constructor(message?: ErrorMessage, data?: any);

                                                                              class TooManyRequests

                                                                              class TooManyRequests extends FeathersError {}

                                                                                constructor

                                                                                constructor(message?: ErrorMessage, data?: any);

                                                                                  class Unavailable

                                                                                  class Unavailable extends FeathersError {}

                                                                                    constructor

                                                                                    constructor(message?: ErrorMessage, data?: any);

                                                                                      class Unprocessable

                                                                                      class Unprocessable extends FeathersError {}

                                                                                        constructor

                                                                                        constructor(message?: ErrorMessage, data?: any);

                                                                                          Interfaces

                                                                                          interface Errors

                                                                                          interface Errors {}

                                                                                            property 400

                                                                                            400: BadRequest;

                                                                                              property 401

                                                                                              401: NotAuthenticated;

                                                                                                property 402

                                                                                                402: PaymentError;

                                                                                                  property 403

                                                                                                  403: Forbidden;

                                                                                                    property 404

                                                                                                    404: NotFound;

                                                                                                      property 405

                                                                                                      405: MethodNotAllowed;

                                                                                                        property 406

                                                                                                        406: NotAcceptable;

                                                                                                          property 408

                                                                                                          408: Timeout;

                                                                                                            property 409

                                                                                                            409: Conflict;

                                                                                                              property 411

                                                                                                              411: LengthRequired;

                                                                                                                property 422

                                                                                                                422: Unprocessable;

                                                                                                                  property 429

                                                                                                                  429: TooManyRequests;

                                                                                                                    property 500

                                                                                                                    500: GeneralError;

                                                                                                                      property 501

                                                                                                                      501: NotImplemented;

                                                                                                                        property 502

                                                                                                                        502: BadGateway;

                                                                                                                          property 503

                                                                                                                          503: Unavailable;

                                                                                                                            property BadGateway

                                                                                                                            BadGateway: BadGateway;

                                                                                                                              property BadRequest

                                                                                                                              BadRequest: BadRequest;

                                                                                                                                property Conflict

                                                                                                                                Conflict: Conflict;

                                                                                                                                  property FeathersError

                                                                                                                                  FeathersError: FeathersError;

                                                                                                                                    property Forbidden

                                                                                                                                    Forbidden: Forbidden;

                                                                                                                                      property GeneralError

                                                                                                                                      GeneralError: GeneralError;

                                                                                                                                        property LengthRequired

                                                                                                                                        LengthRequired: LengthRequired;

                                                                                                                                          property MethodNotAllowed

                                                                                                                                          MethodNotAllowed: MethodNotAllowed;

                                                                                                                                            property NotAcceptable

                                                                                                                                            NotAcceptable: NotAcceptable;

                                                                                                                                              property NotAuthenticated

                                                                                                                                              NotAuthenticated: NotAuthenticated;

                                                                                                                                                property NotFound

                                                                                                                                                NotFound: NotFound;

                                                                                                                                                  property NotImplemented

                                                                                                                                                  NotImplemented: NotImplemented;

                                                                                                                                                    property PaymentError

                                                                                                                                                    PaymentError: PaymentError;

                                                                                                                                                      property Timeout

                                                                                                                                                      Timeout: Timeout;

                                                                                                                                                        property TooManyRequests

                                                                                                                                                        TooManyRequests: TooManyRequests;

                                                                                                                                                          property Unavailable

                                                                                                                                                          Unavailable: Unavailable;

                                                                                                                                                            property Unprocessable

                                                                                                                                                            Unprocessable: Unprocessable;

                                                                                                                                                              interface FeathersErrorJSON

                                                                                                                                                              interface FeathersErrorJSON {}

                                                                                                                                                                property className

                                                                                                                                                                className: string;

                                                                                                                                                                  property code

                                                                                                                                                                  code: number;

                                                                                                                                                                    property data

                                                                                                                                                                    data?: any;

                                                                                                                                                                      property errors

                                                                                                                                                                      errors?: any;

                                                                                                                                                                        property message

                                                                                                                                                                        message: string;

                                                                                                                                                                          property name

                                                                                                                                                                          name: string;

                                                                                                                                                                            Type Aliases

                                                                                                                                                                            type DynamicError

                                                                                                                                                                            type DynamicError = Error & { [key: string]: any };

                                                                                                                                                                              type ErrorMessage

                                                                                                                                                                              type ErrorMessage = null | string | DynamicError | { [key: string]: any } | any[];

                                                                                                                                                                                Package Files (1)

                                                                                                                                                                                Dependencies (0)

                                                                                                                                                                                No dependencies.

                                                                                                                                                                                Dev Dependencies (7)

                                                                                                                                                                                Peer Dependencies (0)

                                                                                                                                                                                No peer dependencies.

                                                                                                                                                                                Badge

                                                                                                                                                                                To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@feathersjs/errors.

                                                                                                                                                                                • Markdown
                                                                                                                                                                                  [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@feathersjs/errors)
                                                                                                                                                                                • HTML
                                                                                                                                                                                  <a href="https://www.jsdocs.io/package/@feathersjs/errors"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>