@nextrush/errors

// Base classes
import { HttpError, NextRushError, getHttpStatusMessage } from '@nextrush/errors';

// 4xx Client Errors
import {
  BadRequestError, // 400
  UnauthorizedError, // 401
  ForbiddenError, // 403
  NotFoundError, // 404
  MethodNotAllowedError, // 405
  ConflictError, // 409
  UnprocessableEntityError, // 422
  TooManyRequestsError, // 429
  // ... and more
} from '@nextrush/errors';

// 5xx Server Errors
import {
  InternalServerError, // 500
  NotImplementedError, // 501
  BadGatewayError, // 502
  ServiceUnavailableError, // 503
  GatewayTimeoutError, // 504
  // ... and more
} from '@nextrush/errors';

// Validation errors
import {
  ValidationError,
  RequiredFieldError,
  TypeMismatchError,
  RangeValidationError,
  LengthError,
  PatternError,
  InvalidEmailError,
  InvalidUrlError,
} from '@nextrush/errors';

// Factory functions
import {
  createError,
  badRequest,
  unauthorized,
  forbidden,
  notFound,
  // ... and more
} from '@nextrush/errors';

// Middleware
import { errorHandler, notFoundHandler, catchAsync } from '@nextrush/errors';

import { NotFoundError, BadRequestError } from '@nextrush/errors';

router.get('/users/:id', async (ctx) => {
  const user = await db.users.findById(ctx.params.id);

  if (!user) {
    throw new NotFoundError('User not found');
  }

  ctx.json(user);
});

router.post('/users', async (ctx) => {
  const { email } = ctx.body as { email?: string };

  if (!email) {
    throw new BadRequestError('Email is required');
  }

  // ...
});

class NextRushError extends Error {
  readonly status: number;
  readonly code: string;
  readonly expose: boolean;
  readonly details?: Record<string, unknown>;
  readonly cause?: unknown;
}

class HttpError extends NextRushError {
  constructor(status: number, message?: string, options?: HttpErrorOptions);
}

// Custom error code
throw new BadRequestError('Invalid email format', {
  code: 'INVALID_EMAIL',
});

// With details
throw new UnprocessableEntityError('Validation failed', {
  details: {
    fields: [
      { field: 'email', message: 'Invalid format' },
      { field: 'age', message: 'Must be positive' },
    ],
  },
});

// Wrapping original error
try {
  await database.query(sql);
} catch (err) {
  throw new InternalServerError('Database query failed', {
    cause: err,
  });
}

// Rate limit with retry-after
throw new TooManyRequestsError('Rate limit exceeded', {
  retryAfter: 60, // seconds
});

import {
  ValidationError,
  RequiredFieldError,
  TypeMismatchError,
  RangeValidationError,
  LengthError,
  PatternError,
  InvalidEmailError,
  InvalidUrlError,
} from '@nextrush/errors';

// Validation error with multiple issues
throw new ValidationError([
  { path: 'email', message: 'Required', rule: 'required' },
  { path: 'age', message: 'Must be positive', rule: 'range' },
]);

// Static factory methods
throw ValidationError.fromField('email', 'Invalid format', 'email');
throw ValidationError.fromFields({ email: 'Required', age: 'Must be number' });

// Field-specific errors
throw new RequiredFieldError('email');
throw new TypeMismatchError('age', 'number', 'string');
throw new RangeValidationError('age', 0, 120);
throw new LengthError('password', 8, 100);
throw new PatternError('username', '^[a-z0-9]+$');
throw new InvalidEmailError();
throw new InvalidUrlError();

const error = new ValidationError([
  { path: 'email', message: 'Required', rule: 'required' },
  { path: 'age', message: 'Must be positive', rule: 'range' },
]);

error.hasErrorFor('email'); // true
error.getErrorsFor('email'); // [{ path: 'email', ... }]
error.getFirstError('email'); // 'Required'
error.toFlatObject(); // { email: 'Required', age: 'Must be positive' }

import {
  createError,
  badRequest,
  unauthorized,
  forbidden,
  notFound,
  conflict,
  tooManyRequests,
  internalError,
} from '@nextrush/errors';

// Generic factory
throw createError(400, 'Invalid input');
throw createError(404, 'User not found', { code: 'USER_NOT_FOUND' });

// Named factories
throw badRequest('Invalid email');
throw unauthorized('Token expired');
throw forbidden('Admin only');
throw notFound('User not found');
throw conflict('Email already exists');
throw tooManyRequests('Rate limit exceeded');
throw internalError('Database connection failed');

import { isHttpError } from '@nextrush/errors';

try {
  await someOperation();
} catch (err) {
  if (isHttpError(err)) {
    console.log(err.status, err.code);
  } else {
    throw new InternalServerError('Unexpected error', { cause: err });
  }
}

import { getErrorStatus } from '@nextrush/errors';

const status = getErrorStatus(error); // 500 if not HttpError

import { getSafeErrorMessage } from '@nextrush/errors';

const message = getSafeErrorMessage(error);
// Returns actual message if expose=true, otherwise generic message

import { errorHandler } from '@nextrush/errors';

// Basic usage (logs 5xx as errors, 4xx as warnings)
app.use(errorHandler());

// With options
app.use(
  errorHandler({
    // Include stack trace in responses (default: false)
    includeStack: process.env.NODE_ENV !== 'production',

    // Custom error logger
    logger: (err, ctx) => {
      myLogger.error(err, { path: ctx.path, method: ctx.method });
    },

    // Custom error response transformer
    transform: (err, ctx) => ({
      success: false,
      error: err.message,
      status: ctx.status,
    }),

    // Handle specific error types
    handlers: new Map([
      [
        SyntaxError,
        (err, ctx) => {
          ctx.status = 400;
          ctx.json({ error: 'Invalid JSON' });
        },
      ],
    ]),
  })
);

import { notFoundHandler } from '@nextrush/errors';

// Add after all routes
app.route('/', router);
app.use(notFoundHandler());

// With custom message
app.use(notFoundHandler('Route not found'));

// catchAsync is no longer needed. This works without it:
router.get('/users', async (ctx) => {
  const users = await db.users.findAll();
  ctx.json(users);
});

import { createApp } from '@nextrush/core';
import { createRouter } from '@nextrush/router';
import {
  errorHandler,
  notFoundHandler,
  NotFoundError,
  BadRequestError,
  ConflictError,
} from '@nextrush/errors';

const app = createApp();
const router = createRouter();

// Error handler first (catches all downstream errors)
app.use(
  errorHandler({
    includeStack: process.env.NODE_ENV !== 'production',
  })
);

// Routes
router.get('/users/:id', async (ctx) => {
  const user = await db.users.findById(ctx.params.id);

  if (!user) {
    throw new NotFoundError(`User ${ctx.params.id} not found`);
  }

  ctx.json(user);
});

router.post('/users', async (ctx) => {
  const { email, password } = ctx.body as Record<string, unknown>;

  if (!email || !password) {
    throw new BadRequestError('Email and password required');
  }

  const existing = await db.users.findByEmail(email);
  if (existing) {
    throw new ConflictError('Email already registered');
  }

  const user = await db.users.create({ email, password });
  ctx.status = 201;
  ctx.json(user);
});

app.route('/', router);

// 404 handler last
app.use(notFoundHandler());

import type {
  HttpErrorOptions,
  ValidationIssue,
  ErrorHandlerOptions,
  ErrorMiddleware,
  ErrorContext,
} from '@nextrush/errors';