@furystack/rest-service 4.0.19

package/src/validate.integration.spec.ts

@@ -0,0 +1,218 @@
+import { Injector } from '@furystack/inject'
+import { createClient } from '@furystack/rest-client-got'
+import { usingAsync } from '@furystack/utils'
+import { RequestError } from 'got/dist/source'
+import { JsonResult } from './request-action-implementation'
+import { Validate } from './validate'
+import './injector-extensions'
+
+import schema from './validate.integration.spec.schema.json'
+import { ValidationApi } from 'validate.integration.schema'
+
+// To recreate: yarn ts-json-schema-generator -f tsconfig.json --no-type-check -p packages/rest-service/src/validate.integration.schema.ts -o packages/rest-service/src/validate.integration.spec.schema.json
+
+export const createValidateApi = async () => {
+  const injector = new Injector()
+  const port = Math.round(Math.random() * 1000) + 10000
+  injector.useRestService<ValidationApi>({
+    api: {
+      GET: {
+        '/validate-query': Validate({
+          schema,
+          schemaName: 'ValidateQuery',
+        })(async ({ getQuery }) => JsonResult({ ...getQuery() })),
+        '/validate-url/:id': Validate({
+          schema,
+          schemaName: 'ValidateUrl',
+        })(async ({ getUrlParams }) => JsonResult({ ...getUrlParams() })),
+        '/validate-headers': Validate({
+          schema,
+          schemaName: 'ValidateHeaders',
+        })(async ({ headers }) => JsonResult({ ...headers })),
+        '/mock': undefined as any, // ToDo: Generator and test
+        '/mock/:id': undefined as any, // ToDo: Generator and test
+      },
+      POST: {
+        '/validate-body': Validate({
+          schema,
+          schemaName: 'ValidateBody',
+        })(async ({ getBody }) => {
+          const body = await getBody()
+          return JsonResult({ ...body })
+        }),
+        '/mock': undefined as any, // ToDo: Generator and test
+      },
+      PATCH: {
+        '/mock/:id': undefined as any, // ToDo: Generator and test
+      },
+      DELETE: {
+        '/mock/:id': undefined as any, // ToDo: Generator and test
+      },
+    },
+    port,
+    root: '/api',
+  })
+  const client = createClient<ValidationApi>({
+    endpointUrl: `http://localhost:${port}/api`,
+  })
+  return {
+    dispose: injector.dispose.bind(injector),
+    client,
+  }
+}
+
+describe('Validation integration tests', () => {
+  describe('Validation errors', () => {
+    it('Should validate query', async () => {
+      await usingAsync(await createValidateApi(), async ({ client }) => {
+        expect.assertions(5)
+        try {
+          await client({
+            method: 'GET',
+            action: '/validate-query',
+            query: undefined as any,
+          })
+        } catch (error) {
+          if (error instanceof RequestError) {
+            expect(error.message).toBe('Response code 400 (Bad Request)')
+            expect(error.response?.statusCode).toBe(400)
+            const responseJson = JSON.parse(error.response?.body as string)
+            expect(responseJson.errors[0].params.missingProperty).toEqual('foo')
+            expect(responseJson.errors[1].params.missingProperty).toEqual('bar')
+            expect(responseJson.errors[2].params.missingProperty).toEqual('baz')
+          }
+        }
+      })
+    })
+    it('Should validate url', async () => {
+      await usingAsync(await createValidateApi(), async ({ client }) => {
+        expect.assertions(4)
+        try {
+          await client({
+            method: 'GET',
+            action: '/validate-url/:id',
+            url: undefined as any,
+          })
+        } catch (error) {
+          if (error instanceof RequestError) {
+            expect(error.message).toBe('Response code 400 (Bad Request)')
+            expect(error.response?.statusCode).toBe(400)
+            const responseJson = JSON.parse(error.response?.body as string)
+            expect(responseJson.errors[0].params.type).toEqual('number')
+            expect(responseJson.errors[0].instancePath).toEqual('/url/id')
+          }
+        }
+      })
+    })
+    it('Should validate headers', async () => {
+      await usingAsync(await createValidateApi(), async ({ client }) => {
+        expect.assertions(3)
+        try {
+          await client({
+            method: 'GET',
+            action: '/validate-headers',
+            headers: undefined as any,
+          })
+        } catch (error) {
+          if (error instanceof RequestError) {
+            expect(error.message).toBe('Response code 400 (Bad Request)')
+            expect(error.response?.statusCode).toBe(400)
+            const responseJson = JSON.parse(error.response?.body as string)
+            expect(
+              responseJson.errors.find((e: any) => e.keyword === 'required' && e.message.includes('foo')),
+            ).toBeDefined()
+          }
+        }
+      })
+    })
+    it('Should validate body', async () => {
+      await usingAsync(await createValidateApi(), async ({ client }) => {
+        expect.assertions(3)
+        try {
+          await client({
+            method: 'POST',
+            action: '/validate-body',
+            body: undefined as any,
+          })
+        } catch (error) {
+          if (error instanceof RequestError) {
+            expect(error.message).toBe('Response code 400 (Bad Request)')
+            expect(error.response?.statusCode).toBe(400)
+            const responseJson = JSON.parse(error.response?.body as string)
+            expect(responseJson.errors[0].params.missingProperty).toEqual('body')
+          }
+        }
+      })
+    })
+  })
+
+  describe('Validation Success', () => {
+    it('Should validate query', async () => {
+      await usingAsync(await createValidateApi(), async ({ client }) => {
+        const result = await client({
+          method: 'GET',
+          action: '/validate-query',
+          query: {
+            foo: 'foo',
+            bar: 2,
+            baz: false,
+          },
+        })
+        expect(result.response.statusCode).toBe(200)
+        const responseJson = result.getJson()
+        expect(responseJson.foo).toBe('foo')
+        expect(responseJson.bar).toBe(2)
+        expect(responseJson.baz).toBe(false)
+      })
+    })
+    it('Should validate url', async () => {
+      await usingAsync(await createValidateApi(), async ({ client }) => {
+        const result = await client({
+          method: 'GET',
+          action: '/validate-url/:id',
+          url: { id: 3 },
+        })
+        expect(result.response.statusCode).toBe(200)
+        const responseJson = result.getJson()
+        expect(responseJson.id).toBe(3)
+      })
+    })
+    it('Should validate headers', async () => {
+      await usingAsync(await createValidateApi(), async ({ client }) => {
+        const result = await client({
+          method: 'GET',
+          action: '/validate-headers',
+          headers: {
+            foo: 'foo',
+            bar: 42,
+            baz: true,
+          },
+        })
+        expect(result.response.statusCode).toBe(200)
+        const responseJson = result.getJson()
+        expect(responseJson.foo).toBe('foo')
+        expect(responseJson.bar).toBe(42)
+        expect(responseJson.baz).toBe(true)
+      })
+    })
+    it('Should validate body', async () => {
+      await usingAsync(await createValidateApi(), async ({ client }) => {
+        const result = await client({
+          method: 'POST',
+          action: '/validate-body',
+          body: {
+            foo: 'foo',
+            bar: 42,
+            baz: true,
+          },
+        })
+
+        expect(result.response.statusCode).toBe(200)
+        const responseJson = result.getJson()
+        expect(responseJson.foo).toBe('foo')
+        expect(responseJson.bar).toBe(42)
+        expect(responseJson.baz).toBe(true)
+      })
+    })
+  })
+})

package/src/validate.ts

@@ -0,0 +1,60 @@
+import { ActionResult, RequestAction, RequestActionOptions } from './request-action-implementation'
+import { SchemaValidator } from './schema-validator'
+
+export const Validate =
+  <TSchema extends { definitions: { [K: string]: { required?: string[] } | any } }>(validationOptions: {
+    /**
+     * The Schema object
+     */
+    schema: TSchema
+    /**
+     * Entity key from the JSON Schema object
+     */
+    schemaName: keyof TSchema['definitions']
+  }) =>
+  <T extends { result: any }>(action: RequestAction<T>): RequestAction<T> => {
+    const schema = { ...validationOptions.schema }
+
+    Object.values(schema.definitions).forEach((definition) => {
+      if (definition.required && definition.required.includes('result')) {
+        definition.required = definition.required.filter((value: any) => value !== 'result')
+      }
+      definition.additionalProperties = true
+      if (definition.properties?.headers) {
+        definition.properties.headers.additionalProperties = true
+      }
+    })
+
+    const validator = new SchemaValidator(schema, { coerceTypes: true })
+
+    return async (args: RequestActionOptions<T>): Promise<ActionResult<T>> => {
+      const anyArgs = args as any
+      let body!: any
+      const { headers } = anyArgs
+      const query = anyArgs.getQuery?.()
+      const url = anyArgs.getUrlParams?.()
+      try {
+        body = await anyArgs.getBody?.()
+      } catch (error) {
+        // ignore
+      }
+      validator.isValid(
+        {
+          ...(query ? { query } : {}),
+          ...(body ? { body } : {}),
+          ...(url ? { url } : {}),
+          ...(headers ? { headers } : {}),
+        },
+        { schemaName: validationOptions.schemaName },
+      )
+      return await action({
+        request: args.request,
+        response: args.response,
+        injector: args.injector,
+        headers,
+        getQuery: () => query,
+        getUrlParams: () => url,
+        getBody: () => Promise.resolve(body),
+      } as any)
+    }
+  }