-
-
Notifications
You must be signed in to change notification settings - Fork 446
/
request.ts
249 lines (216 loc) · 6.54 KB
/
request.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
/* eslint-disable @typescript-eslint/no-explicit-any */
/* eslint-disable @typescript-eslint/no-non-null-assertion */
import type { ParamIndexMap, ParamStash, Params } from './router.ts'
import type {
Input,
InputToDataByTarget,
ParamKeys,
ParamKeyToRecord,
RemoveQuestion,
UndefinedIfHavingQuestion,
ValidationTargets,
} from './types.ts'
import { parseBody } from './utils/body.ts'
import type { BodyData, ParseBodyOptions } from './utils/body.ts'
import type { Cookie } from './utils/cookie.ts'
import { parse } from './utils/cookie.ts'
import type { UnionToIntersection } from './utils/types.ts'
import { getQueryParam, getQueryParams, decodeURIComponent_ } from './utils/url.ts'
type Body = {
json: any
text: string
arrayBuffer: ArrayBuffer
blob: Blob
formData: FormData
}
type BodyCache = Partial<Body & { parsedBody: BodyData }>
export class HonoRequest<P extends string = '/', I extends Input['out'] = {}> {
raw: Request
private _s: ParamStash
private vData: { [K in keyof ValidationTargets]?: {} } // Short name of validatedData
private _p: ParamIndexMap | Params = {}
path: string
bodyCache: BodyCache = {}
constructor(request: Request, path: string = '/', paramStash: ParamStash = []) {
this.raw = request
this.path = path
this._s = paramStash
this.vData = {}
}
setParams(params: ParamIndexMap | Params) {
this._p = params
}
param<P2 extends string = P>(
key: RemoveQuestion<ParamKeys<P2>>
): UndefinedIfHavingQuestion<ParamKeys<P2>>
param<P2 extends string = P>(): UnionToIntersection<ParamKeyToRecord<ParamKeys<P2>>>
param(key?: string): unknown {
if (this._s) {
if (key) {
const param = this._s[this._p[key] as any] ?? this._p[key]
return param ? (/\%/.test(param) ? decodeURIComponent_(param) : param) : undefined
} else {
const decoded: Record<string, string> = {}
const keys = Object.keys(this._p)
for (let i = 0, len = keys.length; i < len; i++) {
const key = keys[i]
const value = this._s[this._p[key] as any] ?? this._p[key]
if (value && typeof value === 'string') {
decoded[key] = /\%/.test(value) ? decodeURIComponent_(value) : value
}
}
return decoded
}
}
return null
}
query(key: string): string | undefined
query(): Record<string, string>
query(key?: string) {
return getQueryParam(this.url, key)
}
queries(key: string): string[] | undefined
queries(): Record<string, string[]>
queries(key?: string) {
return getQueryParams(this.url, key)
}
header(name: string): string | undefined
header(): Record<string, string>
header(name?: string) {
if (name) return this.raw.headers.get(name.toLowerCase()) ?? undefined
const headerData: Record<string, string | undefined> = {}
this.raw.headers.forEach((value, key) => {
headerData[key] = value
})
return headerData
}
/** @deprecated
* Use Cookie Middleware instead of `c.req.cookie()`. The `c.req.cookie()` will be removed in v4.
*
* @example
*
* import { getCookie } from 'hono/cookie'
* // ...
* app.get('/', (c) => c.text(getCookie(c, 'cookie-name')))
*/
cookie(key: string): string | undefined
/** @deprecated
* Use Cookie Middleware instead of `c.req.cookie()`. The `c.req.cookie()` will be removed in v4.
*
* @example
*
* import { getCookie } from 'hono/cookie'
* // ...
* app.get('/', (c) => c.json(getCookie(c)))
*/
cookie(): Cookie
cookie(key?: string) {
const cookie = this.raw.headers.get('Cookie')
if (!cookie) return
const obj = parse(cookie)
if (key) {
const value = obj[key]
return value
} else {
return obj
}
}
async parseBody<T extends BodyData = BodyData>(options?: ParseBodyOptions): Promise<T> {
if (this.bodyCache.parsedBody) return this.bodyCache.parsedBody as T
const parsedBody = await parseBody<T>(this, options)
this.bodyCache.parsedBody = parsedBody
return parsedBody
}
private cachedBody = (key: keyof Body) => {
const { bodyCache, raw } = this
const cachedBody = bodyCache[key]
if (cachedBody) return cachedBody
/**
* If an arrayBuffer cache is exist,
* use it for creating a text, json, and others.
*/
if (bodyCache.arrayBuffer) {
return (async () => {
return await new Response(bodyCache.arrayBuffer)[key]()
})()
}
return (bodyCache[key] = raw[key]())
}
json<T = any>(): Promise<T> {
return this.cachedBody('json')
}
text(): Promise<string> {
return this.cachedBody('text')
}
arrayBuffer(): Promise<ArrayBuffer> {
return this.cachedBody('arrayBuffer')
}
blob(): Promise<Blob> {
return this.cachedBody('blob')
}
formData(): Promise<FormData> {
return this.cachedBody('formData')
}
addValidatedData(target: keyof ValidationTargets, data: {}) {
this.vData[target] = data
}
valid<T extends keyof I & keyof ValidationTargets>(target: T): InputToDataByTarget<I, T>
valid(target: keyof ValidationTargets) {
return this.vData[target] as unknown
}
get url() {
return this.raw.url
}
get method() {
return this.raw.method
}
/** @deprecated
* Use `c.req.raw.headers` instead of `c.req.headers`. The `c.req.headers` will be removed in v4.
* Or you can get the header values with using `c.req.header`.
* @example
*
* app.get('/', (c) => {
* const userAgent = c.req.header('User-Agent')
* //...
* })
*/
get headers() {
return this.raw.headers
}
/** @deprecated
* Use `c.req.raw.body` instead of `c.req.body`. The `c.req.body` will be removed in v4.
*/
get body() {
return this.raw.body
}
/** @deprecated
* Use `c.req.raw.bodyUsed` instead of `c.req.bodyUsed`. The `c.req.bodyUsed` will be removed in v4.
*/
get bodyUsed() {
return this.raw.bodyUsed
}
/** @deprecated
* Use `c.req.raw.integrity` instead of `c.req.integrity`. The `c.req.integrity` will be removed in v4.
*/
get integrity() {
return this.raw.integrity
}
/** @deprecated
* Use `c.req.raw.keepalive` instead of `c.req.keepalive`. The `c.req.keepalive` will be removed in v4.
*/
get keepalive() {
return this.raw.keepalive
}
/** @deprecated
* Use `c.req.raw.referrer` instead of `c.req.referrer`. The `c.req.referrer` will be removed in v4.
*/
get referrer() {
return this.raw.referrer
}
/** @deprecated
* Use `c.req.raw.signal` instead of `c.req.signal`. The `c.req.signal` will be removed in v4.
*/
get signal() {
return this.raw.signal
}
}