Merge pull request #17 from storyofams/feat/parser-options

Parser options

Author: leeuwis

lib/e2e.test.ts

@@ -47,7 +47,7 @@ class TestHandler {
   public read(
     @Header('Content-Type') contentType: string,
     @Query('id') id: string,
-    @Query('step', ParseNumberPipe) step: number,
+    @Query('step', ParseNumberPipe({ nullable: false })) step: number,
     @Query('redirect', ParseBooleanPipe) redirect: boolean
   ) {
     return { contentType, id, step, redirect, test: this.testField };
@@ -77,7 +77,7 @@ class TestHandler {
     const { 'content-type': contentType } = headers;
     const { id } = query;
 
-    return res.status(200).json({ contentType, id, receivedBody: body, test: this.testField });
+    res.status(200).json({ contentType, id, receivedBody: body, test: this.testField });
   }
 }
 
@@ -112,6 +112,19 @@ describe('E2E', () => {
         })
       ));
 
+  it('read', () =>
+    request(server)
+      .get('/?id=my-id&redirect=true')
+      .set('Content-Type', 'application/json')
+      .expect(400)
+      .then(res =>
+        expect(res).toMatchObject({
+          body: {
+            message: 'step is a required parameter.'
+          }
+        })
+      ));
+
   it('create', () =>
     request(server)
       .post('/')

lib/internals/handler.ts

@@ -67,8 +67,15 @@ export function Handler(method?: HttpVerb): MethodDecorator {
           metaParameters.map(async ({ location, name, pipes, index }) => {
             let returnValue = await getParameterValue(req, res, bodyParamType, { location, name, index });
 
-            if (returnValue && pipes && pipes.length) {
-              pipes.forEach(pipeFn => (returnValue = pipeFn(returnValue)));
+            if (pipes && pipes.length) {
+              pipes.forEach(
+                pipeFn =>
+                  (returnValue = pipeFn.name
+                    ? // Bare pipe function. i.e: `ParseNumberPipe`
+                      (pipeFn as Function).call(null, null).call(null, returnValue, name)
+                    : // Pipe with options. i.e: `ParseNumberPipe({ nullable: false })`
+                      pipeFn.call(null, returnValue, name))
+              );
             }
 
             return returnValue;

lib/pipes/ParameterPipe.ts

@@ -1 +1,5 @@
-export type ParameterPipe<T> = (value: any) => T;
+export interface PipeOptions {
+  nullable?: boolean;
+}
+
+export type ParameterPipe<T> = (value: any, name?: string) => T;

lib/pipes/parseBoolean.pipe.spec.ts

@@ -1,10 +1,14 @@
 import { ParseBooleanPipe } from './parseBoolean.pipe';
 
 describe('ParseBooleanPipe', () => {
-  it('Should parse the given string as boolean (true)', () => expect(ParseBooleanPipe('true')).toStrictEqual(true));
+  it('Should parse the given string as boolean (true)', () => expect(ParseBooleanPipe()('true')).toStrictEqual(true));
 
-  it('Should parse the given string as boolean (false)', () => expect(ParseBooleanPipe('false')).toStrictEqual(false));
+  it('Should parse the given string as boolean (false)', () =>
+    expect(ParseBooleanPipe()('false')).toStrictEqual(false));
+
+  it('Should throw required error the given value is empty', () =>
+    expect(() => ParseBooleanPipe({ nullable: false })('')).toThrow());
 
   it('Should throw when the given string is not a boolean string', () =>
-    expect(() => ParseBooleanPipe('test')).toThrow());
+    expect(() => ParseBooleanPipe()('test')).toThrow());
 });

lib/pipes/parseBoolean.pipe.ts

@@ -1,13 +1,19 @@
 import { BadRequestException } from '../exceptions';
+import type { ParameterPipe, PipeOptions } from './ParameterPipe';
+import { validatePipeOptions } from './validatePipeOptions';
 
-export function ParseBooleanPipe(value: any): boolean {
-  if (value === true || value === 'true') {
-    return true;
-  }
+export function ParseBooleanPipe(options?: PipeOptions): ParameterPipe<boolean> {
+  return (value: any, name?: string) => {
+    validatePipeOptions(value, name, options);
 
-  if (value === false || value === 'false') {
-    return false;
-  }
+    if (value === true || value === 'true') {
+      return true;
+    }
 
-  throw new BadRequestException('Validation failed (boolean string is expected)');
+    if (value === false || value === 'false') {
+      return false;
+    }
+
+    throw new BadRequestException(`Validation failed${name ? ` for ${name}` : ''} (boolean string is expected)`);
+  };
 }

lib/pipes/parseNumber.pipe.spec.ts

@@ -1,11 +1,14 @@
 import { ParseNumberPipe } from './parseNumber.pipe';
 
 describe('ParseNumberPipe', () => {
-  it('Should parse the given string as number', () => expect(ParseNumberPipe('10')).toStrictEqual(10));
+  it('Should parse the given string as number', () => expect(ParseNumberPipe()('10')).toStrictEqual(10));
 
   it('Should parse the given string as number with decimal points', () =>
-    expect(ParseNumberPipe('07.99')).toStrictEqual(7.99));
+    expect(ParseNumberPipe()('07.99')).toStrictEqual(7.99));
+
+  it('Should throw required error the given value is empty', () =>
+    expect(() => ParseNumberPipe({ nullable: false })('')).toThrow());
 
   it('Should throw when the given string is not a numeric string', () =>
-    expect(() => ParseNumberPipe('test')).toThrow());
+    expect(() => ParseNumberPipe()('test')).toThrow());
 });

lib/pipes/parseNumber.pipe.ts

@@ -1,9 +1,16 @@
 import { BadRequestException } from '../exceptions';
+import type { ParameterPipe, PipeOptions } from './ParameterPipe';
+import { validatePipeOptions } from './validatePipeOptions';
 
-export function ParseNumberPipe(value: any): number {
-  const isNumeric = ['string', 'number'].includes(typeof value) && !isNaN(parseFloat(value)) && isFinite(value);
-  if (!isNumeric) {
-    throw new BadRequestException('Validation failed (numeric string is expected)');
-  }
-  return parseFloat(value);
+export function ParseNumberPipe(options?: PipeOptions): ParameterPipe<number> {
+  return (value: any, name?: string) => {
+    validatePipeOptions(value, name, options);
+
+    const isNumeric = ['string', 'number'].includes(typeof value) && !isNaN(parseFloat(value)) && isFinite(value);
+    if (!isNumeric) {
+      throw new BadRequestException(`Validation failed${name ? ` for ${name}` : ''} (numeric string is expected)`);
+    }
+
+    return parseFloat(value);
+  };
 }

lib/pipes/validatePipeOptions.ts

@@ -0,0 +1,8 @@
+import { BadRequestException } from '../exceptions';
+import type { PipeOptions } from './ParameterPipe';
+
+export function validatePipeOptions(value: any, name?: string, options?: PipeOptions) {
+  if (!options?.nullable && (value == null || value.toString().trim().length === 0)) {
+    throw new BadRequestException(name ? `${name} is a required parameter.` : 'Missing a required parameter.');
+  }
+}