Custom Error On OpenAPIHono

[userdehghani]

i cant use zValidator like this reference. now i need to custom my error to simple json response {"error": "Invalid User ID"} with error code 400 but its frustrating. any body can help?

userRoute.ts

import { z } from '@hono/zod-openapi'
import { OpenAPIHono, createRoute } from '@hono/zod-openapi'

const userRoute = new OpenAPIHono()

const userValidate = z.object({
    id: z.coerce.number().int().positive().openapi({ example: 1, description: "User ID" }),
})

const route = createRoute({
    method: 'get',
    path: '/{id}',
    request: {
        params: userValidate,
    },
    responses: {
        200: {
            content: {
                "application/json": {
                    schema: userValidate,
                }
            },
            description: 'Retrieve the user',
        },
    },
})

userRoute.openapi(
    route,
    async (c) => {
        const { id } = c.req.valid('param');
        return c.json({ id });
    }
);


export default userRoute

ErrorHandler.ts

import { Context, Next } from 'hono';
import { ZodError } from 'zod';

const ErrorHandler = async (c: Context, next: Next) => {
    try {
        await next();
    } catch (error) {
        if (error instanceof ZodError) {
            return c.text('Invalid user ID', 400);
        }

        return c.text('Internal Server Error', 500);
    }
};

export default ErrorHandler;

Application.ts

import { OpenAPIHono } from '@hono/zod-openapi'
import { swaggerUI } from '@hono/swagger-ui'
import config from "../config"
import userRoute from '../modules/Auth/userRoute'
import ErrorHandler from '../exceptions/ErrorHandler'

const app = new OpenAPIHono()

app.use('*', ErrorHandler);

app.route('/auth', userRoute)

app.doc('/openapi', {
    openapi: '3.0.0',
    info: {
        title: 'My API',
        version: '1.0.0',
        description: 'API documentation using Zod and Hono'
    }
})
app.get('/docs', swaggerUI({ url: '/openapi' }))

app.get('/', async (c) => {
    return c.json({
        "message": "You can build amazing stuff using our API. Please take a look at our documentation:",
        "link": `http://${config.HOST}${':' + config.PORT}/openapi`
    })
})

export { app }

main.ts

import 'dotenv/config';
import config from "./config"
import { app } from "./providers/Application";
import { drizzle } from 'drizzle-orm/node-postgres';

const db = drizzle(config.DATABASE_URL);

async function bootstrap() {

  await db.execute('SELECT 1');
  console.log("> Connected to the database.");

  Bun.serve({
    fetch: app.fetch,
    port: config.PORT,
    hostname: config.HOST,
  })

  console.log(`> Server running on http://${config.HOST}:${config.PORT}`);
}

bootstrap()

[SyahrulBhudiF]

https://github.com/SyahrulBhudiF/Hono-Starter-Code

look at this bro, i've created that handle error at global and handle the route better.
I hope this helps you

[SyahrulBhudiF]

if u want to rewrite zod error to simple response, try this

export const honoApp = () =>
    new OpenAPIHono<{ Variables: ApplicationVariables }>({
        defaultHook: (result) => {
            if (result.success) {
                return;
            }

            const errors = result.error.errors
                .map(error => `Invalid ${error.path[0]} (${error.message})`)
                .join(", ");

            logger.error('Validation error: ' + errors);

            throw new HTTPException(422, {
                message: errors,
            });
        },
    });

this will catch the validation error and throw it aggain as HTTPException and will be catch at this Global Error :

export default async function errorUtil(err: Error | HTTPResponseError, c: any) {
    if (err instanceof HTTPException) {
        c.status(err.status);
        logger.error(err.message);
        return c.json(ResponseUtil.error(err.message));

    } else if (err instanceof ZodError) {
        c.status(400);
        const errors = err.errors.map(error => ({
            message: `Invalid ${error.path[0]}`
        }));

        logger.error('Validation error: ' + JSON.stringify(errors));

        return c.json(ResponseUtil.error(errors));
    } else {
        c.status(500);
        logger.error('Internal server error: ' + err);
        return c.json(ResponseUtil.error('Internal server error'));
    }
}

I hope this can help you better