Express Hono

Express

apps/express/handler/post_handler.ts

import express from 'express'
import { Post } from '@packages/prisma'
import { PostsService } from '@packages/service'

export class PostHandler {
  static apply(app: express.Application) {
    app.post('/posts', this.createPost.bind(this))
    app.get('/posts', this.getPostList.bind(this))
    app.put('/posts/:id', this.updatePost.bind(this))
    app.delete('/posts/:id', this.deletePost.bind(this))
  }

  static async createPost(req: express.Request, res: express.Response) {
    try {
      const { post }: { post: string } = req.body
      await PostsService.createPost(post)
      return res.status(201).json({ message: 'Created' })
    } catch (e) {
      console.error(e)
      return res.status(500).json({ message: 'Internal Server Error' })
    }
  }

  static async getPostList(req: express.Request, res: express.Response) {
    try {
      const { page, rows } = req.query
      const pageNumber = Number(page)
      const rowsNumber = Number(rows)
      if (isNaN(pageNumber) || isNaN(rowsNumber) || pageNumber < 1 || rowsNumber < 1) {
        return res.status(400).json({ message: 'Bad Request' })
      }
      const limit = rowsNumber
      const offset = (pageNumber - 1) * rowsNumber
      const res_post: Post[] = await PostsService.getPosts(limit, offset)
      return res.status(200).json(res_post)
    } catch (e) {
      console.error(e)
      return res.status(500).json({ message: 'Internal Server Error' })
    }
  }

  static async updatePost(req: express.Request, res: express.Response) {
    try {
      const { id } = req.params
      const { post }: { post: string } = req.body
      await PostsService.putPost(id, post)
      return res.sendStatus(204)
    } catch (e) {
      console.error(e)
      return res.status(500).json({ message: 'Internal Server Error' })
    }
  }

  static async deletePost(req: express.Request, res: express.Response) {
    try {
      const { id } = req.params
      await PostsService.deletePost(id)
      return res.sendStatus(204)
    } catch (e) {
      console.error(e)
      return res.status(500).json({ message: 'Internal Server Error' })
    }
  }
}

Hono

apps/hono/src/handler/post_handler.ts

import { Hono } from 'hono'
import { zValidator } from '@hono/zod-validator'
import { z } from 'zod'
import { Post } from '@packages/prisma'
import { postSchema } from '@packages/schemas'
import { PostsService } from '@packages/service'

export class PostHandler {
  static apply(app: Hono) {
    return app
      .post(
        '/posts',
        zValidator(
          'json',
          postSchema.pick({
            post: true,
          }),
        ),
        async (c) => {
          const { post } = c.req.valid('json')
          await PostsService.createPost(post)
          return c.json({ message: 'Created' }, 201)
        },
      )
      .get(
        '/posts',
        zValidator(
          'query',
          z.object({
            page: z.string(),
            rows: z.string(),
          }),
        ),
        async (c) => {
          const { page, rows } = c.req.valid('query')
          const pageNumber = parseInt(page)
          const rowsPerPage = parseInt(rows)
          if (isNaN(pageNumber) || isNaN(rowsPerPage) || pageNumber < 1 || rowsPerPage < 1) {
            return c.json({ message: 'Bad Request' }, 400)
          }
          const limit = rowsPerPage
          const offset = (pageNumber - 1) * rowsPerPage
          const posts: Post[] = await PostsService.getPosts(limit, offset)
          return c.json(posts, 200)
        },
      )
      .put(
        '/posts/:id',
        zValidator('param', z.object({ id: z.string().uuid() })),
        zValidator('json', postSchema.pick({ post: true })),
        async (c) => {
          const { id } = c.req.valid('param')
          const { post } = c.req.valid('json')
          await PostsService.putPost(id, post)
          return new Response(null, { status: 204 })
        },
      )
      .delete(
        '/posts/:id',
        zValidator(
          'param',
          z.object({
            id: z.string().uuid(),
          }),
        ),
        async (c) => {
          const { id } = c.req.valid('param')
          await PostsService.deletePost(id)
          return new Response(null, { status: 204 })
        },
      )
  }
}