jsDocs.io logo

@feathersjs/errors

  • Version 4.5.15
  • Published
  • 43 kB
  • 1 dependency
  • MIT license

Install

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

Overview

Common error types for Feathers apps

Index

Variables

Functions

Classes

Interfaces

Variables

variable errors

const errors: Errors;

    variable types

    const types: Errors;

      Functions

      function convert

      convert: (error: any) => FeathersError;

        Classes

        class BadGateway

        class BadGateway extends FeathersError {}

          constructor

          constructor(msg?: string | Error, data?: any);

            class BadRequest

            class BadRequest extends FeathersError {}

              constructor

              constructor(msg?: string | Error, data?: any);

                class Conflict

                class Conflict extends FeathersError {}

                  constructor

                  constructor(msg?: string | Error, data?: any);

                    class FeathersError

                    class FeathersError extends Error {}

                      constructor

                      constructor(
                          msg: string | Error,
                          name: string,
                          code: number,
                          className: string,
                          data: any
                      );

                        property className

                        readonly className: string;

                          property code

                          readonly code: number;

                            property data

                            readonly data?: {};

                              property errors

                              readonly errors: any;

                                method toJSON

                                toJSON: () => FeathersErrorJSON;

                                  class Forbidden

                                  class Forbidden extends FeathersError {}

                                    constructor

                                    constructor(msg?: string | Error, data?: any);

                                      class GeneralError

                                      class GeneralError extends FeathersError {}

                                        constructor

                                        constructor(msg?: string | Error, data?: any);

                                          class LengthRequired

                                          class LengthRequired extends FeathersError {}

                                            constructor

                                            constructor(msg?: string | Error, data?: any);

                                              class MethodNotAllowed

                                              class MethodNotAllowed extends FeathersError {}

                                                constructor

                                                constructor(msg?: string | Error, data?: any);

                                                  class NotAcceptable

                                                  class NotAcceptable extends FeathersError {}

                                                    constructor

                                                    constructor(msg?: string | Error, data?: any);

                                                      class NotAuthenticated

                                                      class NotAuthenticated extends FeathersError {}

                                                        constructor

                                                        constructor(msg?: string | Error, data?: any);

                                                          class NotFound

                                                          class NotFound extends FeathersError {}

                                                            constructor

                                                            constructor(msg?: string | Error, data?: any);

                                                              class NotImplemented

                                                              class NotImplemented extends FeathersError {}

                                                                constructor

                                                                constructor(msg?: string | Error, data?: any);

                                                                  class PaymentError

                                                                  class PaymentError extends FeathersError {}

                                                                    constructor

                                                                    constructor(msg?: string | Error, data?: any);

                                                                      class Timeout

                                                                      class Timeout extends FeathersError {}

                                                                        constructor

                                                                        constructor(msg?: string | Error, data?: any);

                                                                          class TooManyRequests

                                                                          class TooManyRequests extends FeathersError {}

                                                                            constructor

                                                                            constructor(msg?: string | Error, data?: any);

                                                                              class Unavailable

                                                                              class Unavailable extends FeathersError {}

                                                                                constructor

                                                                                constructor(msg?: string | Error, data?: any);

                                                                                  class Unprocessable

                                                                                  class Unprocessable extends FeathersError {}

                                                                                    constructor

                                                                                    constructor(msg?: string | Error, 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

                                                                                                                                                            readonly className: string;

                                                                                                                                                              property code

                                                                                                                                                              readonly code: number;

                                                                                                                                                                property data

                                                                                                                                                                readonly data?: any;

                                                                                                                                                                  property errors

                                                                                                                                                                  readonly errors: any;

                                                                                                                                                                    property message

                                                                                                                                                                    readonly message: string;

                                                                                                                                                                      property name

                                                                                                                                                                      readonly name: string;

                                                                                                                                                                        Package Files (1)

                                                                                                                                                                        Dependencies (1)

                                                                                                                                                                        Dev Dependencies (3)

                                                                                                                                                                        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>