01
import { Hono } from 'hono'
02
import catalogRoute from './catalog/list.route'
03
import orderRoute from './order/detail.route'
04
import healthRoute from './system/health.route'
05
import pingRoute from './system/ping.route'
06
import userRoute from './user/profile.route'
07

08
type Bindings = {
09
  APP_ENV: 'development' | 'test' | 'production'
10
}
11

12
const routes = new Hono<{ Bindings: Bindings }>()
13

14
const appRoutes = routes
15
  .route('/health', healthRoute)
16
  .route('/rpc/system/ping', pingRoute)
17
  .route('/rpc/catalog', catalogRoute)
18
  .route('/rpc/user', userRoute)
19
  .route('/rpc/order', orderRoute)
20

21
export type RoutesType = typeof appRoutes
22

23
export default appRoutes

01
import { Hono } from 'hono'
02
import routes from './routes'
03

04
type AppErrorStatus = 400 | 401 | 403 | 404 | 409 | 422 | 500 | 504
05

06
type Bindings = {
07
  APP_ENV: 'development' | 'test' | 'production'
08
}
09

10
const app = new Hono<{ Bindings: Bindings }>()
11

12
app.onError((error, c) => {
13
  ...
14
})
15

16
app.notFound((c) => {
17
  ...
18
})
19

20
app.route('/', routes)
21

22
export type AppType = typeof routes
23

24
export default app

01
import type { BizCode } from './biz-code'
02

03
// meta 放请求级别的信息，data/error 放业务结果本身。
04
export type ApiMeta = {
05
  requestId: string
06
  timestamp: string
07
}
08

09
export type ApiSuccess<T> = {
10
  ok: true
11
  data: T
12
  meta: ApiMeta
13
}
14

15
export type ApiError = {
16
  code: BizCode
17
  message: string
18
  details?: unknown
19
}
20

21
export type ApiFailure = {
22
  ok: false
23
  error: ApiError
24
  meta: ApiMeta
25
}
26

27
// 所有接口最终都落在 success 或 failure 这两个分支里。
28
export type ApiResponse<T> = ApiSuccess<T> | ApiFailure
29

30
// 这两个 helper 只是统一拼装响应结构，调用方不用每次手写 ok/data/meta。
31
export function buildSuccess<T>(data: T, meta: ApiMeta): ApiSuccess<T> {
32
  return {
33
    ok: true,
34
    data,
35
    meta,
36
  }
37
}
38

39
export function buildFailure(
40
  error: ApiError,
41
  meta: ApiMeta,
42
): ApiFailure {
43
  return {
44
    ok: false,
45
    error,
46
    meta,
47
  }
48
}

01
import { z } from 'zod'
02

03
export const CatalogListResponseSchema = z.object({
04
  items: z.array(
05
    z.object({
06
      id: z.string(),
07
      name: z.string(),
08
      category: z.string(),
09
    }),
10
  ),
11
})
12

13
export type CatalogListResponse = z.infer<typeof CatalogListResponseSchema>

01
import { getWebServerEnv } from '@/env.server'
02

03
const env = getWebServerEnv()
04

05
export function serverURL(path: string) {
06
  return new URL(path, env.API_BASE_URL).toString()
07
}
08

09
export function createJsonRequestInit(body?: unknown): RequestInit {
10
  if (body === undefined) {
11
    return {
12
      method: 'GET',
13
    }
14
  }
15

16
  return {
17
    method: 'POST',
18
    headers: {
19
      'content-type': 'application/json',
20
    },
21
    body: JSON.stringify(body),
22
  }
23
}

01
import type {
02
  ApiResponse,
03
  PingRequest,
04
  PingResponse,
05
} from '@repo/contracts'
06
import { BizCode } from '@repo/contracts'
07
import { createJsonRequestInit, serverURL } from '@/api/client'
08

09
export async function postPing(
10
  payload: PingRequest,
11
): Promise<ApiResponse<PingResponse>> {
12
  try {
13
    const response = await fetch(
14
      serverURL('/rpc/system/ping'),
15
      createJsonRequestInit(payload),
16
    )
17

18
    return await response.json()
19
  } catch (error) {
20
    return {
21
      ok: false,
22
      error: {
23
        code: BizCode.SYSTEM_UPSTREAM_TIMEOUT,
24
        message: error instanceof Error ? error.message : 'API request failed',
25
      },
26
      meta: {
27
        requestId: 'unavailable',
28
        timestamp: new Date().toISOString(),
29
      },
30
    }
31
  }
32
}