Errors API

class FeathersError extends Error {
  constructor(
    message: ErrorMessage,
    name: string,
    code: number,
    className: string,
    data: any
  )
}

toJSON(): FeathersErrorJSON

const error = new BadRequest('Invalid input', {
  field: 'email'
})

const json = error.toJSON()
// {
//   name: 'BadRequest',
//   message: 'Invalid input',
//   code: 400,
//   className: 'bad-request',
//   data: { field: 'email' }
// }

new ErrorClass(message?: ErrorMessage, data?: any)

import { BadRequest } from '@feathersjs/errors'

throw new BadRequest('Invalid request parameters')

throw new BadRequest('Validation failed', {
  errors: {
    email: 'Email is required',
    password: 'Password must be at least 8 characters'
  }
})

import { NotAuthenticated } from '@feathersjs/errors'

throw new NotAuthenticated('Authentication token missing')

throw new NotAuthenticated('Invalid credentials')

import { PaymentError } from '@feathersjs/errors'

throw new PaymentError('Payment required to access this resource')

throw new PaymentError('Credit card declined', {
  paymentId: '123',
  reason: 'insufficient_funds'
})

import { Forbidden } from '@feathersjs/errors'

throw new Forbidden('You do not have permission to access this resource')

throw new Forbidden('Admin access required')

import { NotFound } from '@feathersjs/errors'

throw new NotFound('User not found')

throw new NotFound(`User with id ${id} does not exist`)

import { MethodNotAllowed } from '@feathersjs/errors'

throw new MethodNotAllowed('DELETE method is not allowed on this resource')

import { NotAcceptable } from '@feathersjs/errors'

throw new NotAcceptable('Only JSON format is supported')

import { Timeout } from '@feathersjs/errors'

throw new Timeout('Request took too long to process')

import { Conflict } from '@feathersjs/errors'

throw new Conflict('A user with this email already exists')

throw new Conflict('Resource version mismatch', {
  currentVersion: 2,
  requestedVersion: 1
})

import { Gone } from '@feathersjs/errors'

throw new Gone('This resource has been permanently deleted')

import { LengthRequired } from '@feathersjs/errors'

throw new LengthRequired('Content-Length header is required')

import { Unprocessable } from '@feathersjs/errors'

throw new Unprocessable('Cannot process this request', {
  reason: 'duplicate_entry'
})

import { TooManyRequests } from '@feathersjs/errors'

throw new TooManyRequests('Rate limit exceeded. Try again in 60 seconds', {
  retryAfter: 60
})

import { GeneralError } from '@feathersjs/errors'

throw new GeneralError('An unexpected error occurred')

import { NotImplemented } from '@feathersjs/errors'

throw new NotImplemented('This feature is not yet implemented')

import { BadGateway } from '@feathersjs/errors'

throw new BadGateway('Upstream service is unavailable')

import { Unavailable } from '@feathersjs/errors'

throw new Unavailable('Service is under maintenance', {
  retryAfter: 3600
})

type ErrorMessage = 
  | null 
  | string 
  | Error 
  | { message?: string; errors?: any; [key: string]: any } 
  | any[]

// String message
throw new BadRequest('Invalid input')

// Object with message and data
throw new BadRequest({
  message: 'Validation failed',
  errors: {
    email: 'Invalid format',
    age: 'Must be positive'
  }
})

// Existing Error object
try {
  await dangerousOperation()
} catch (err) {
  throw new GeneralError(err)
}

// Additional data as second parameter
throw new NotFound('User not found', {
  userId: 123,
  timestamp: new Date()
})

interface FeathersErrorJSON {
  name: string
  message: string
  code: number
  className: string
  data?: any
  errors?: any
}

const handleError = async (context) => {
  const { error } = context
  
  // Log the error
  console.error(`Error in ${context.path}.${context.method}:`, error)
  
  // Transform unknown errors
  if (!(error instanceof FeathersError)) {
    context.error = new GeneralError('An unexpected error occurred')
  }
}

app.hooks({
  error: {
    all: [handleError]
  }
})

class UserService {
  async get(id, params) {
    const user = await db.users.findById(id)
    
    if (!user) {
      throw new NotFound(`User ${id} not found`)
    }
    
    // Check authorization
    if (user.id !== params.user?.id && !params.user?.isAdmin) {
      throw new Forbidden('You can only access your own user data')
    }
    
    return user
  }
  
  async create(data, params) {
    // Validate input
    if (!data.email) {
      throw new BadRequest('Email is required')
    }
    
    // Check for duplicates
    const existing = await db.users.findByEmail(data.email)
    if (existing) {
      throw new Conflict('A user with this email already exists')
    }
    
    return await db.users.create(data)
  }
}

try {
  const user = await app.service('users').get(123)
} catch (error) {
  if (error instanceof NotFound) {
    console.log('User does not exist')
  } else if (error instanceof Forbidden) {
    console.log('Access denied')
  } else {
    console.error('Unexpected error:', error)
  }
}

import { convert } from '@feathersjs/errors'

const error = {
  name: 'NotFound',
  message: 'User not found',
  data: { userId: 123 }
}

const feathersError = convert(error)
// Returns: NotFound instance

import { errors } from '@feathersjs/errors'

const NotFoundError = errors[404]
throw new NotFoundError('Resource not found')

const BadRequestError = errors[400]
throw new BadRequestError('Invalid input')

import {
  FeathersError,
  BadRequest,
  NotAuthenticated,
  PaymentError,
  Forbidden,
  NotFound,
  MethodNotAllowed,
  NotAcceptable,
  Timeout,
  Conflict,
  Gone,
  LengthRequired,
  Unprocessable,
  TooManyRequests,
  GeneralError,
  NotImplemented,
  BadGateway,
  Unavailable,
  errors,
  convert
} from '@feathersjs/errors'

interface FeathersErrorJSON {
  name: string
  message: string
  code: number
  className: string
  data?: any
  errors?: any
}

type ErrorMessage = 
  | null 
  | string 
  | Error 
  | { message?: string; errors?: any; [key: string]: any } 
  | any[]