@teardown/errors 0.1.29

package/package.json

@@ -0,0 +1,44 @@
+{
+	"name": "@teardown/errors",
+	"version": "0.1.29",
+	"private": false,
+	"publishConfig": {
+		"access": "public"
+	},
+	"type": "module",
+	"files": [
+		"src/**/*"
+	],
+	"main": "./src/index.ts",
+	"module": "./src/index.ts",
+	"types": "./src/index.ts",
+	"exports": {
+		".": {
+			"types": "./src/index.ts",
+			"import": "./src/index.ts",
+			"default": "./src/index.ts"
+		},
+		"./package.json": "./package.json"
+	},
+	"scripts": {
+		"build": "tsc --project ./tsconfig.lib.json",
+		"dev": "tsc --watch --project ./tsconfig.lib.json",
+		"typecheck": "tsc --noEmit --project ./tsconfig.lib.json",
+		"fmt": "bun x biome format --write ./src",
+		"lint": "bun x biome lint --write ./src",
+		"check": "bun x biome check ./src",
+		"prepublishOnly": "bun x turbo run build"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "2.3.7",
+		"@teardown/tsconfig": "1.0.0",
+		"@types/bun": "1.3.3"
+	},
+	"peerDependencies": {
+		"typescript": "^5.9.3",
+		"zod": "^4"
+	},
+	"dependencies": {
+		"elysia": "1.4.16"
+	}
+}

package/src/index.test.ts

@@ -0,0 +1,130 @@
+import { describe, expect, it } from "bun:test";
+import {
+	BadRequestError,
+	ErrorCodes,
+	ForbiddenError,
+	InternalServerError,
+	NotFoundError,
+	TeardownError,
+	UnauthorizedError,
+} from "./index";
+
+describe("Errors", () => {
+	describe("TeardownError", () => {
+		it("should create error with code and message", () => {
+			const error = new TeardownError(ErrorCodes.BadRequest, "Test error");
+
+			expect(error.code).toBe(ErrorCodes.BadRequest);
+			expect(error.message).toBe("Test error");
+			expect(error.status).toBe(ErrorCodes.BadRequest);
+		});
+
+		it("should have status property matching code", () => {
+			const error = new TeardownError(ErrorCodes.InternalServerError);
+
+			expect(error.status).toBe(error.code);
+			expect(error.status).toBe(500);
+		});
+	});
+
+	describe("ForbiddenError", () => {
+		it("should create error with default message", () => {
+			const error = new ForbiddenError();
+
+			expect(error.code).toBe(ErrorCodes.Forbidden);
+			expect(error.message).toBe("Forbidden");
+			expect(error.status).toBe(403);
+		});
+
+		it("should create error with custom message", () => {
+			const error = new ForbiddenError("Custom forbidden message");
+
+			expect(error.code).toBe(ErrorCodes.Forbidden);
+			expect(error.message).toBe("Custom forbidden message");
+		});
+	});
+
+	describe("UnauthorizedError", () => {
+		it("should create error with default message", () => {
+			const error = new UnauthorizedError();
+
+			expect(error.code).toBe(ErrorCodes.Unauthorized);
+			expect(error.message).toBe("Authorization required");
+			expect(error.status).toBe(401);
+		});
+
+		it("should create error with custom message", () => {
+			const error = new UnauthorizedError("Invalid credentials");
+
+			expect(error.code).toBe(ErrorCodes.Unauthorized);
+			expect(error.message).toBe("Invalid credentials");
+		});
+	});
+
+	describe("BadRequestError", () => {
+		it("should create error with default message", () => {
+			const error = new BadRequestError();
+
+			expect(error.code).toBe(ErrorCodes.BadRequest);
+			expect(error.message).toBe("Bad request");
+			expect(error.status).toBe(400);
+		});
+
+		it("should create error with custom message", () => {
+			const error = new BadRequestError("Invalid input data");
+
+			expect(error.code).toBe(ErrorCodes.BadRequest);
+			expect(error.message).toBe("Invalid input data");
+		});
+	});
+
+	describe("NotFoundError", () => {
+		it("should create error with default message", () => {
+			const error = new NotFoundError();
+
+			expect(error.code).toBe(ErrorCodes.NotFound);
+			expect(error.message).toBe("Not found");
+			expect(error.status).toBe(404);
+		});
+
+		it("should create error with custom message", () => {
+			const error = new NotFoundError("Resource not found");
+
+			expect(error.code).toBe(ErrorCodes.NotFound);
+			expect(error.message).toBe("Resource not found");
+		});
+	});
+
+	describe("InternalServerError", () => {
+		it("should create error with default message", () => {
+			const error = new InternalServerError();
+
+			expect(error.code).toBe(ErrorCodes.InternalServerError);
+			expect(error.message).toBe("Internal server error");
+			expect(error.status).toBe(500);
+		});
+
+		it("should create error with custom message", () => {
+			const error = new InternalServerError("Database connection failed");
+
+			expect(error.code).toBe(ErrorCodes.InternalServerError);
+			expect(error.message).toBe("Database connection failed");
+		});
+	});
+
+	describe("ErrorCodes enum", () => {
+		it("should have correct status codes", () => {
+			expect(ErrorCodes.OK).toBe(200);
+			expect(ErrorCodes.Created).toBe(201);
+			expect(ErrorCodes.Accepted).toBe(202);
+			expect(ErrorCodes.BadRequest).toBe(400);
+			expect(ErrorCodes.Unauthorized).toBe(401);
+			expect(ErrorCodes.Forbidden).toBe(403);
+			expect(ErrorCodes.NotFound).toBe(404);
+			expect(ErrorCodes.UnprocessableContent).toBe(422);
+			expect(ErrorCodes.TooManyRequests).toBe(429);
+			expect(ErrorCodes.InternalServerError).toBe(500);
+		});
+	});
+});
+

package/src/index.ts

@@ -0,0 +1,293 @@
+import { Elysia, type ValidationError } from "elysia";
+import { ZodError } from "zod";
+
+export enum ErrorCodes {
+	Continue = 100,
+	SwitchingProtocols = 101,
+	Processing = 102,
+	EarlyHints = 103,
+	OK = 200,
+	Created = 201,
+	Accepted = 202,
+	NonAuthoritativeInformation = 203,
+	NoContent = 204,
+	ResetContent = 205,
+	PartialContent = 206,
+	MultiStatus = 207,
+	AlreadyReported = 208,
+	MultipleChoices = 300,
+	MovedPermanently = 301,
+	Found = 302,
+	SeeOther = 303,
+	NotModified = 304,
+	TemporaryRedirect = 307,
+	PermanentRedirect = 308,
+	BadRequest = 400,
+	Unauthorized = 401,
+	PaymentRequired = 402,
+	Forbidden = 403,
+	NotFound = 404,
+	MethodNotAllowed = 405,
+	NotAcceptable = 406,
+	ProxyAuthenticationRequired = 407,
+	RequestTimeout = 408,
+	Conflict = 409,
+	Gone = 410,
+	LengthRequired = 411,
+	PreconditionFailed = 412,
+	PayloadTooLarge = 413,
+	UriTooLong = 414,
+	UnsupportedMediaType = 415,
+	RangeNotSatisfiable = 416,
+	ExpectationFailed = 417,
+	ImATeapot = 418,
+	MisdirectedRequest = 421,
+	UnprocessableContent = 422,
+	Locked = 423,
+	FailedDependency = 424,
+	TooEarly = 425,
+	UpgradeRequired = 426,
+	PreconditionRequired = 428,
+	TooManyRequests = 429,
+	RequestHeaderFieldsTooLarge = 431,
+	UnavailableForLegalReasons = 451,
+	InternalServerError = 500,
+	NotImplemented = 501,
+	BadGateway = 502,
+	ServiceUnavailable = 503,
+	GatewayTimeout = 504,
+	HttpVersionNotSupported = 505,
+	VariantAlsoNegotiates = 506,
+	InsufficientStorage = 507,
+	LoopDetected = 508,
+	NotExtended = 510,
+	NetworkAuthenticationRequired = 511,
+}
+
+export class TeardownError extends Error {
+	code: ErrorCodes;
+
+	constructor(code: ErrorCodes, message?: string) {
+		super(message);
+		this.code = code;
+	}
+
+	get status() {
+		return this.code;
+	}
+}
+
+export class ForbiddenError extends TeardownError {
+	constructor(message = "Forbidden") {
+		super(ErrorCodes.Forbidden, message);
+	}
+}
+
+export class UnauthorizedError extends TeardownError {
+	constructor(message = "Authorization required") {
+		super(ErrorCodes.Unauthorized, message);
+	}
+}
+
+export class BadRequestError extends TeardownError {
+	constructor(message = "Bad request") {
+		super(ErrorCodes.BadRequest, message);
+	}
+}
+
+export class FailedRequestError extends TeardownError {
+	constructor(message = "Failed request") {
+		super(ErrorCodes.InternalServerError, message);
+	}
+}
+
+export class NotFoundError extends TeardownError {
+	constructor(message = "Not found") {
+		super(ErrorCodes.NotFound, message);
+	}
+}
+
+export class UnprocessableContentError extends TeardownError {
+	constructor(message = "Unprocessable content") {
+		super(ErrorCodes.UnprocessableContent, message);
+	}
+}
+
+export class InternalServerError extends TeardownError {
+	constructor(message = "Internal server error") {
+		super(ErrorCodes.InternalServerError, message);
+	}
+}
+
+export class ConflictError extends TeardownError {
+	constructor(message = "Conflict") {
+		super(ErrorCodes.Conflict, message);
+	}
+}
+
+export class RateLimitError extends Error {
+	constructor(
+		public readonly resetTime: Date | null,
+		public readonly remaining: number | null,
+		public readonly limit: number | null,
+		message = "Rate limit exceeded"
+	) {
+		super(message);
+		this.name = "RateLimitError";
+	}
+}
+
+export class ConfigurationError extends TeardownError {
+	constructor(message = "Configuration not setup or is invalid") {
+		super(ErrorCodes.InternalServerError, message);
+	}
+}
+
+export interface ValidationErrorResponse {
+	error: string;
+	message: string;
+	path?: string;
+}
+
+export interface ErrorResponse {
+	success: false;
+	error: string;
+	message: string;
+	path?: string;
+	[key: string]: unknown;
+}
+
+export interface ErrorHandlerResult {
+	status: number;
+	body: ErrorResponse;
+}
+
+const handleValidationError = (error: ValidationError): ErrorHandlerResult => {
+	const message = error instanceof Error ? error.message : "Validation failed";
+	return {
+		status: 422,
+		body: {
+			success: false,
+			error: "VALIDATION",
+			message: message || "Validation failed",
+		},
+	};
+};
+
+const handleValidCode = (parsedCode: number): ErrorHandlerResult => {
+	return {
+		status: parsedCode,
+		body: {
+			success: false,
+			error: "Unknown error",
+			message: "An unknown error occurred",
+		},
+	};
+};
+
+const handleZodError = (error: ZodError): ErrorHandlerResult => {
+	const message = error instanceof Error ? error.message : "Validation failed";
+	return {
+		status: 400,
+		body: {
+			success: false,
+			error: "Validation failed",
+			message,
+		},
+	};
+};
+
+export function handleError(error: unknown, code: number | string = 500): ErrorHandlerResult {
+	// Handle Elysia ValidationError (duck-typed check)
+	if (code === "VALIDATION" || (error && typeof error === "object" && "type" in error && error.type === "validation")) {
+		return handleValidationError(error as ValidationError);
+	}
+
+	// Handle ZodError (duck-typed check for issues array)
+	if (
+		error instanceof ZodError &&
+		error &&
+		typeof error === "object" &&
+		"issues" in error &&
+		Array.isArray(error.issues)
+	) {
+		return handleZodError(error as ZodError);
+	}
+
+	if (error instanceof TeardownError) {
+		return {
+			status: error.status,
+			body: {
+				success: false,
+				error: error.constructor.name,
+				message: error.message,
+			},
+		};
+	}
+
+	// Handle JSON-encoded validation errors
+	if (error && typeof error === "object" && "message" in error) {
+		const errorWithMessage = error as { message: unknown };
+		if (typeof errorWithMessage.message === "string") {
+			try {
+				const validationError = JSON.parse(errorWithMessage.message);
+				if (validationError && Array.isArray(validationError) && validationError.length > 0) {
+					const firstError = validationError[0];
+					const path = firstError?.path?.join(".");
+					return {
+						status: 400,
+						body: {
+							success: false,
+							error: "Validation failed",
+							message: firstError?.message ?? "Invalid input",
+							path: path && path.length > 0 ? path : undefined,
+						},
+					};
+				}
+			} catch {
+				// Not a JSON validation error, continue
+			}
+		}
+	}
+
+	const parsedCode = Number(code);
+
+	if (!Number.isNaN(parsedCode)) {
+		return handleValidCode(parsedCode);
+	}
+
+	return {
+		status: 500,
+		body: {
+			success: false,
+			error: "Internal server error",
+			message: "An unexpected error occurred",
+		},
+	};
+}
+
+export const ElysiaErrors = new Elysia()
+	.error({
+		FORBIDDEN: ForbiddenError,
+		NOT_FOUND: NotFoundError,
+		INTERNAL_SERVER_ERROR: InternalServerError,
+		BAD_REQUEST: BadRequestError,
+		UNAUTHORIZED: UnauthorizedError,
+		UNPROCESSABLE_ENTITY: UnprocessableContentError,
+		TOO_MANY_REQUESTS: RateLimitError,
+		SERVICE_UNAVAILABLE: InternalServerError,
+	})
+	.onError(({ error, code, set }) => {
+		console.error("[ErrorHandler] Unhandled error:", {
+			code,
+			error,
+			errorType: typeof error,
+			errorConstructor: error?.constructor?.name,
+			errorMessage: error instanceof Error ? error.message : String(error),
+			errorStack: error instanceof Error ? error.stack : undefined,
+		});
+		const result = handleError(error, code);
+		set.status = result.status;
+		return result.body;
+	})
+	.as("global");