feat: implements useValidatedQuery

src/body.ts

@@ -0,0 +1,14 @@
+import type { Static, TSchema } from '@sinclair/typebox'
+import { createError, useBody, CompatibilityEvent } from 'h3'
+import { useValidator } from './utils'
+
+export async function useValidatedBody<T extends TSchema> (event: CompatibilityEvent, schema: T) {
+  const body = await useBody(event)
+  const validate = useValidator().compile(schema)
+
+  if (!validate(body)) {
+    throw createError({ statusCode: 400, statusMessage: `body ${validate.errors[0].message}` })
+  }
+
+  return body as Static<T>
+}

src/index.ts

@@ -1,20 +1,4 @@
-import type { Static, TSchema } from '@sinclair/typebox'
-import { createError, useBody, CompatibilityEvent } from 'h3'
-import Ajv from 'ajv'
-
-const ajv = new Ajv({
-  keywords: ['kind', 'modifier']
-})
-
-export async function useValidatedBody<T extends TSchema> (event: CompatibilityEvent, schema: T) {
-  const body = await useBody(event)
-  const validate = ajv.compile(schema)
-
-  if (!validate(body)) {
-    throw createError({ statusCode: 400, statusMessage: `body ${validate.errors[0].message}` })
-  }
-
-  return body as Static<T>
-}
-
 export { Type } from '@sinclair/typebox'
+
+export * from './body'
+export * from './query'

src/query.ts

@@ -0,0 +1,14 @@
+import type { Static, TSchema } from '@sinclair/typebox'
+import { createError, CompatibilityEvent, useQuery } from 'h3'
+import { useValidator } from './utils'
+
+export function useValidatedQuery<T extends TSchema> (event: CompatibilityEvent, schema: T) {
+  const query = useQuery(event)
+  const validate = useValidator().compile(schema)
+
+  if (!validate(query)) {
+    throw createError({ statusCode: 400, statusMessage: `query ${validate.errors[0].message}` })
+  }
+
+  return query as Static<T>
+}

src/utils/index.ts

@@ -0,0 +1 @@
+export * from './validator'

src/utils/validator.ts

@@ -0,0 +1,13 @@
+import Ajv from 'ajv'
+
+let instance: Ajv
+
+export function useValidator () {
+  if (!instance) {
+    instance = new Ajv({
+      keywords: ['kind', 'modifier']
+    })
+  }
+
+  return instance
+}

test/index.test.ts → test/body.test.ts

@@ -19,13 +19,15 @@ describe('useValidatedBody', () => {
 
   it('returns 200 OK if body matches validation schema', async () => {
     app.use('/validate', async req => await useValidatedBody(req, bodySchema))
+
     const res = await request.post('/validate').send({ required: true })
 
     expect(res.status).toEqual(200)
   })
 
   it('throws 400 Bad Request if body does not match validation schema', async () => {
     app.use('/validate', async req => await useValidatedBody(req, bodySchema))
+
     const res = await request.post('/validate').send({})
 
     expect(res.status).toEqual(400)

test/query.test.ts

@@ -0,0 +1,39 @@
+import supertest, { SuperTest, Test } from 'supertest'
+import { describe, beforeEach, it, expect } from 'vitest'
+import { createApp, App } from 'h3'
+import { useValidatedQuery, Type } from '../src'
+
+describe('useValidatedQuery', () => {
+  let app: App
+  let request: SuperTest<Test>
+
+  beforeEach(() => {
+    app = createApp({ debug: false })
+    request = supertest(app)
+  })
+
+  const querySchema = Type.Object({
+    required: Type.String()
+  })
+
+  it('returns 200 OK if query matches validation schema', async () => {
+    app.use('/validate', req => useValidatedQuery(req, querySchema))
+
+    const res = await request.get('/validate?required')
+
+    expect(res.status).toEqual(200)
+  })
+
+  it('throws 400 Bad Request if query does not match validation schema', async () => {
+    app.use('/validate', req => useValidatedQuery(req, querySchema))
+
+    const res = await request.get('/validate')
+
+    expect(res.status).toEqual(400)
+    expect(res.body).toEqual(
+      expect.objectContaining({
+        statusMessage: "query must have required property 'required'"
+      })
+    )
+  })
+})