01
import { z } from 'zod'
02

03
export const BizCode = {
04
  COMMON_INVALID_REQUEST: 'COMMON.INVALID_REQUEST',
05
  COMMON_NOT_FOUND: 'COMMON.NOT_FOUND',
06
  AUTH_UNAUTHORIZED: 'AUTH.UNAUTHORIZED',
07
  AUTH_FORBIDDEN: 'AUTH.FORBIDDEN',
08
  BIZ_CONFLICT: 'BIZ.CONFLICT',
09
  BIZ_RULE_VIOLATION: 'BIZ.RULE_VIOLATION',
10
  SYSTEM_INTERNAL_ERROR: 'SYSTEM.INTERNAL_ERROR',
11
  SYSTEM_UPSTREAM_TIMEOUT: 'SYSTEM.UPSTREAM_TIMEOUT',
12
} as const
13

14
export type BizCode = (typeof BizCode)[keyof typeof BizCode]
15

16
export interface ApiMeta {
17
  requestId: string
18
  timestamp: string
19
}
20

21
export interface ApiSuccess<T> {
22
  ok: true
23
  data: T
24
  meta: ApiMeta
25
}
26

27
export interface ApiError<E = unknown> {
28
  code: BizCode
29
  message: string
30
  details?: E
31
}
32

33
export interface ApiFailure<E = unknown> {
34
  ok: false
35
  error: ApiError<E>
36
  meta: ApiMeta
37
}
38

39
export type ApiResponse<T, E = unknown> = ApiSuccess<T> | ApiFailure<E>
40

41
export const PingRequestSchema = z.object({
42
  name: z.string().trim().min(1),
43
})
44

45
export const PingResponseSchema = z.object({
46
  service: z.literal('api'),
47
  message: z.string(),
48
})
49

50
export type PingRequest = z.infer<typeof PingRequestSchema>
51
export type PingResponse = z.infer<typeof PingResponseSchema>
52

53
export function buildSuccess<T>(data: T, meta: ApiMeta): ApiSuccess<T> {
54
  return { ok: true, data, meta }
55
}
56

57
export function buildFailure<E = unknown>(
58
  error: ApiError<E>,
59
  meta: ApiMeta,
60
): ApiFailure<E> {
61
  return { ok: false, error, meta }
62
}

01
import {
02
  BizCode,
03
  PingRequestSchema,
04
  buildFailure,
05
  buildSuccess,
06
  type ApiMeta,
07
} from '@repo/contracts'
08
import { Hono } from 'hono'
09
import { HTTPException } from 'hono/http-exception'
10
import { validator } from 'hono/validator'
11

12
type AppErrorStatus = 400 | 401 | 403 | 404 | 409 | 422 | 500 | 504
13

14
class AppError extends Error {
15
  constructor(
16
    readonly code: BizCode,
17
    message: string,
18
    readonly status: AppErrorStatus,
19
    readonly details?: unknown,
20
  ) {
21
    super(message)
22
  }
23
}
24

25
const app = new Hono()
26

27
function createMeta(): ApiMeta {
28
  return {
29
    requestId: crypto.randomUUID(),
30
    timestamp: new Date().toISOString(),
31
  }
32
}
33

34
app.onError((error, c) => {
35
  const meta = createMeta()
36

37
  if (error instanceof AppError) {
38
    const errorMsg = { code: error.code, message: error.message, details: error.details }
39
    const res = buildFailure(errorMsg, meta);
40
    return c.json(res, error.status);
41
  }
42

43
  if (error instanceof HTTPException) {
44
    const errorMsg = { code: BizCode.COMMON_INVALID_REQUEST, message: error.message }
45
    const res = buildFailure(errorMsg, meta);
46
    return c.json(res, error.status);
47
  }
48

49
  console.error(error)
50

51
  const errorMsg = { code: BizCode.SYSTEM_INTERNAL_ERROR, message: 'Internal server error' }
52
  const res = buildFailure(errorMsg, meta);
53
  return c.json(res, 500);
54
})
55

56
app.notFound((c) => {
57
  const errorMsg = { code: BizCode.COMMON_NOT_FOUND, message: 'Not found' }
58
  const res = buildFailure(errorMsg, createMeta());
59
  return c.json(res, 404);
60
})
61

62
const routes = app
63
  .get('/health', (c) => {
64
    const res = buildSuccess({ service: 'api' }, createMeta());
65
    return c.json(res);
66
  })
67
  .post('/rpc/system/ping', validator('json', (value, c) => {
68
      const parsed = PingRequestSchema.safeParse(value)
69

70
      if (!parsed.success) {
71
        const errorMsg = {
72
          code: BizCode.COMMON_INVALID_REQUEST,
73
          message: 'Invalid request payload',
74
          details: parsed.error.flatten(),
75
        }
76
        return c.json(buildFailure(errorMsg, createMeta()), 400);
77
      }
78

79
      return parsed.data
80
    }),
81
    (c) => {
82
      const payload = c.req.valid('json')
83
      const successMsg = { service: 'api', message: `pong, ${payload.name}` } 
84
      const res = buildSuccess(successMsg, createMeta());
85
    return c.json(res);
86
  });
87

88
export type AppType = typeof routes;
89

90
export default app;

1
import app from './app'
2

3
export default app