Merge branch 'master' of github.com:woutervh-/typescript-is

Author: woutervh-

README.md

@@ -137,6 +137,7 @@ There are some options to configure the transformer.
 | `ignoreFunctions` *(deprecated, use `functionBehavior` instead)* | Boolean (default: `false`). If `true`, when the transformer encounters a function, it will ignore it and simply return `true`. If `false`, an error is generated at compile time. |
 | `functionBehavior` | One of `error`, `ignore`, or `basic` (default: `error`). Determines the behavior of transformer when encountering a function. `error` will cause a compile-time error, `ignore` will cause the validation function to always return `true`, and `basic` will do a simple function-type-check. Overrides `ignoreFunctions`. |
 | `disallowSuperfluousObjectProperties` | Boolean (default: `false`). If `true`, objects are checked for having superfluous properties and will cause the validation to fail if they do. If `false`, no check for superfluous properties is made. |
+| `transformNonNullExpressions` | Boolean (default: `false`). If `true`, non-null expressions (eg. `foo!.bar`) are checked to not be `null` or `undefined` |
 | `emitDetailedErrors` | Boolean or `auto` (default: `auto`). The generated validation functions can return detailed error messages, pointing out where and why validation failed. These messages are used by `assertType<T>()`, but are ignored by `is<T>()`. If `false`, validation functions return empty error messages, decreasing code size. `auto` will generate detailed error messages for assertions, but not for type checks. `true` will always generate detailed error messages, matching the behaviour of version 0.18.3 and older. |
 
 If you are using `ttypescript`, you can include the options in your `tsconfig.json`:
@@ -152,6 +153,7 @@ If you are using `ttypescript`, you can include the options in your `tsconfig.js
                 "ignoreMethods": true,
                 "functionBehavior": "ignore",
                 "disallowSuperfluousObjectProperties": true,
+                "transformNonNullExpressions": true,
                 "emitDetailedErrors": "auto"
             }
         ]
@@ -259,6 +261,74 @@ new A().method(42) === 42; // true
 new A().method('42' as any); // will throw error
 ```
 
+### async and `Promise` returning methods 
+`AssertType` can also work correctly with `async` methods, returning promise rejected with `TypeGuardError`
+
+To enable this functionality, you need to emit decorators metadata for your TypeScript project.
+
+```json
+{
+    "compilerOptions": {
+      "emitDecoratorMetadata": true
+    }
+}
+```
+
+Then `AssertType` will work with async methods and `Promise` returning methods automatically.
+```typescript
+import { ValidateClass, AssertType } from 'typescript-is';
+
+@ValidateClass()
+class A {
+    async method(@AssertType({ async: true }) value: number) {
+        // You can safely use value as a number
+        return value;
+    }
+
+    methodPromise(@AssertType({ async: true }) value: number): Promise<number> {
+        // You can safely use value as a number
+        return Promise.resolve(value);
+    }
+}
+
+new A().method(42).then(value => value === 42 /* true */); 
+new A().method('42' as any).catch(error => {
+    // error will be of TypeGuardError type
+})
+new A().methodPromise('42' as any).catch(error => {
+    // error will be of TypeGuardError type
+})
+```
+
+If you want to throw synchronously for some reason, you can override the behaviour using with `@AssertType({ async: false })`:
+```typescript
+import { ValidateClass, AssertType } from 'typescript-is';
+
+@ValidateClass()
+class A {
+    async method(@AssertType({ async: false }) value: number) {
+        // You can safely use value as a number
+        return value;
+    }
+}
+
+new A().method(42).then(value => value === 42 /* true */);
+new A().method('42' as any); // will throw error
+```
+
+If you cannot or don't want to enable decorators metadata, you still make AssertType reject with promise using `@AssertType({ async: true })` 
+```typescript
+import { ValidateClass, AssertType } from 'typescript-is';
+
+@ValidateClass()
+class A {
+    async method(@AssertType({ async: true }) value: number) {
+        // You can safely use value as a number
+        return value;
+    }
+}
+```
+
 ## Strict equality (`equals`, `createEquals`, `assertEquals`, `createAssertEquals`)
 
 This family of functions check not only whether the passed object is assignable to the specified type, but also checks that the passed object does not contain any more than is necessary. In other words: the type is also "assignable" to the object. This functionality is equivalent to specifying `disallowSuperfluousObjectProperties` in the options, the difference is that this will apply only to the specific function call. For example:

index.d.ts

@@ -125,7 +125,7 @@ export function createAssertEquals<T>(): (object: any) => T;
    new A().method('0' as any); // will throw an error
    ```
  */
-export function AssertType(): (target: object, propertyKey: string | symbol, parameterIndex: number) => void;
+export function AssertType(options?: { async: boolean }): (target: object, propertyKey: string | symbol, parameterIndex: number) => void;
 
 /**
  * Overrides methods in the target class with a proxy that will first validate the argument types.

index.js

@@ -47,7 +47,11 @@ function AssertType(assertion, options = {}) {
     require('reflect-metadata');
     return function (target, propertyKey, parameterIndex) {
         const assertions = Reflect.getOwnMetadata(assertionsMetadataKey, target, propertyKey) || [];
-        assertions[parameterIndex] = { assertion, options };
+        if(Reflect.getOwnMetadata('design:returntype', target, propertyKey) === Promise) {
+            assertions[parameterIndex] = { assertion, options: Object.assign({ async: true }, options) };
+        } else {
+            assertions[parameterIndex] = { assertion, options };
+        }
         Reflect.defineMetadata(assertionsMetadataKey, assertions, target, propertyKey);
     };
 }
@@ -66,7 +70,12 @@ function ValidateClass(errorConstructor = TypeGuardError) {
                         }
                         const errorObject = assertions[i].assertion(args[i]);
                         if (errorObject !== null) {
-                            throw new errorConstructor(errorObject, args[i]);
+                            const errorInstance = new errorConstructor(errorObject, args[i]);
+                            if(assertions[i].options.async) {
+                                return Promise.reject(errorInstance);
+                            } else {
+                                throw errorInstance;
+                            }
                         }
                     }
                     return originalMethod.apply(this, args);

src/transform-inline/transform-node.ts

@@ -8,7 +8,8 @@ import { sliceMapValues } from './utils';
 function createArrowFunction(type: ts.Type, rootName: string, optional: boolean, partialVisitorContext: PartialVisitorContext) {
     const functionMap: VisitorContext['functionMap'] = new Map();
     const functionNames: VisitorContext['functionNames'] = new Set();
-    const visitorContext = { ...partialVisitorContext, functionNames, functionMap };
+    const typeIdMap: VisitorContext['typeIdMap'] = new Map();
+    const visitorContext: VisitorContext = { ...partialVisitorContext, functionNames, functionMap, typeIdMap };
     const emitDetailedErrors = !!visitorContext.options.emitDetailedErrors;
     const functionName = partialVisitorContext.options.shortCircuit
         ? visitShortCircuit(visitorContext)
@@ -136,6 +137,55 @@ export function transformNode(node: ts.Node, visitorContext: PartialVisitorConte
                 ]
             );
         }
+    } else if (visitorContext.options.transformNonNullExpressions && ts.isNonNullExpression(node)) {
+        const expression = node.expression
+        return ts.factory.updateNonNullExpression(node, ts.factory.createParenthesizedExpression(ts.factory.createConditionalExpression(
+            ts.factory.createParenthesizedExpression(ts.factory.createBinaryExpression(
+                ts.factory.createBinaryExpression(
+                    ts.factory.createTypeOfExpression(expression),
+                    ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken),
+                    ts.factory.createStringLiteral('undefined')
+                ),
+                ts.factory.createToken(ts.SyntaxKind.BarBarToken),
+                ts.factory.createBinaryExpression(
+                    expression,
+                    ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken),
+                    ts.factory.createNull()
+                )
+            )),
+            ts.factory.createToken(ts.SyntaxKind.QuestionToken),
+            ts.factory.createCallExpression(
+                ts.factory.createParenthesizedExpression(ts.factory.createArrowFunction(
+                    undefined,
+                    undefined,
+                    [],
+                    undefined,
+                    ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+                    ts.factory.createBlock(
+                        [ts.factory.createThrowStatement(ts.factory.createNewExpression(
+                            ts.factory.createIdentifier('Error'),
+                            undefined,
+                            [ts.factory.createTemplateExpression(
+                                ts.factory.createTemplateHead(`${expression.getText()} was non-null asserted but is `),
+                                [ts.factory.createTemplateSpan(
+                                    expression,
+                                    ts.factory.createTemplateTail(
+                                        ''
+                                    )
+                                )]
+                            )]
+                        ))
+                        ],
+                        false
+                    )
+                )),
+                undefined,
+                []
+            ),
+            ts.factory.createToken(ts.SyntaxKind.ColonToken),
+            expression
+        )))
     }
     return node;
 }
+

src/transform-inline/transformer.ts

@@ -42,6 +42,7 @@ export default function transformer(program: ts.Program, options?: { [Key: strin
             ignoreMethods: !!(options && options.ignoreMethods),
             functionBehavior: getFunctionBehavior(options),
             disallowSuperfluousObjectProperties: !!(options && options.disallowSuperfluousObjectProperties),
+            transformNonNullExpressions: !!(options && options.transformNonNullExpressions),
             emitDetailedErrors: getEmitDetailedErrors(options)
         },
         typeMapperStack: [],

src/transform-inline/visitor-context.d.ts

@@ -6,12 +6,14 @@ interface Options {
     ignoreMethods: boolean;
     functionBehavior: 'error' | 'ignore' | 'basic';
     disallowSuperfluousObjectProperties: boolean;
+    transformNonNullExpressions: boolean;
     emitDetailedErrors: boolean | 'auto';
 }
 
 export interface VisitorContext extends PartialVisitorContext {
     functionNames: Set<string>;
     functionMap: Map<string, ts.FunctionDeclaration>;
+    typeIdMap: Map<string, string>;
 }
 
 export interface PartialVisitorContext {

src/transform-inline/visitor-type-name.ts

@@ -39,9 +39,19 @@ function visitArrayObjectType(type: ts.ObjectType, visitorContext: VisitorContex
     return `sa_${numberIndexName}_ea`;
 }
 
-function visitRegularObjectType(type: ts.ObjectType) {
-    const id: string = (type as unknown as { id: string }).id;
-    return `_${id}`;
+function getTypeIndexById(type: ts.Type, { typeIdMap }: VisitorContext) {
+    const id = (type as unknown as { id: string | number }).id.toString();
+    let index = typeIdMap.get(id);
+    if (index === undefined) {
+        index = typeIdMap.size.toString();
+        typeIdMap.set(id, index);
+    }
+    return index;
+}
+
+function visitRegularObjectType(type: ts.Type, visitorContext: VisitorContext) {
+    const index = getTypeIndexById(type, visitorContext);
+    return `_${index}`;
 }
 
 function visitTypeReference(type: ts.TypeReference, visitorContext: VisitorContext, mode: NameMode) {
@@ -71,7 +81,7 @@ function visitObjectType(type: ts.ObjectType, visitorContext: VisitorContext, mo
     } else if (checkIsDateClass(type)) {
         return '_date';
     } else {
-        return visitRegularObjectType(type);
+        return visitRegularObjectType(type, visitorContext);
     }
 }
 
@@ -98,7 +108,7 @@ function visitIndexedAccessType(type: ts.IndexedAccessType, visitorContext: Visi
 
 export function visitType(type: ts.Type, visitorContext: VisitorContext, mode: NameMode): string {
     let name: string;
-    const id: string = (type as unknown as { id: string }).id;
+    const index = getTypeIndexById(type, visitorContext);
     if ((ts.TypeFlags.Any & type.flags) !== 0) {
         name = VisitorUtils.getAnyFunction(visitorContext);
     } else if ((ts.TypeFlags.Unknown & type.flags) !== 0) {
@@ -118,25 +128,25 @@ export function visitType(type: ts.Type, visitorContext: VisitorContext, mode: N
     } else if ((ts.TypeFlags.String & type.flags) !== 0) {
         name = VisitorUtils.getStringFunction(visitorContext);
     } else if ((ts.TypeFlags.BooleanLiteral & type.flags) !== 0) {
-        name = `_${id}`;
+        name = `_${index}`;
     } else if (tsutils.isTypeReference(type) && visitorContext.previousTypeReference !== type) {
         name = visitTypeReference(type, visitorContext, mode);
     } else if ((ts.TypeFlags.TypeParameter & type.flags) !== 0) {
         name = visitTypeParameter(type, visitorContext, mode);
     } else if (tsutils.isObjectType(type)) {
         name = visitObjectType(type, visitorContext, mode);
     } else if (tsutils.isLiteralType(type)) {
-        name = `_${id}`;
+        name = `_${index}`;
     } else if (tsutils.isUnionOrIntersectionType(type)) {
         name = visitUnionOrIntersectionType(type, visitorContext, mode);
     } else if ((ts.TypeFlags.NonPrimitive & type.flags) !== 0) {
-        name = `_${id}`;
+        name = `_${index}`;
     } else if ((ts.TypeFlags.Index & type.flags) !== 0) {
         name = visitIndexType(type, visitorContext);
     } else if (tsutils.isIndexedAccessType(type)) {
         name = visitIndexedAccessType(type, visitorContext);
     } else if ((ts.TypeFlags.TemplateLiteral & type.flags) !== 0) {
-        name = `_${id}`;
+        name = `_${index}`;
     } else {
         throw new Error('Could not generate type-check; unsupported type with flags: ' + type.flags);
     }
@@ -153,7 +163,8 @@ export function visitType(type: ts.Type, visitorContext: VisitorContext, mode: N
     if (tsutils.isTypeReference(type) && type.typeArguments !== undefined) {
         for (const typeArgument of type.typeArguments) {
             const resolvedType = VisitorUtils.getResolvedTypeParameter(typeArgument, visitorContext) || typeArgument;
-            name += `_${(resolvedType as unknown as { id: string }).id}`;
+            const resolvedTypeIndex = getTypeIndexById(resolvedType, visitorContext);
+            name += `_${resolvedTypeIndex}`;
         }
     }
     return name;

test-fixtures/issue-104.ts

@@ -0,0 +1,21 @@
+import {AssertType, ValidateClass} from '../index';
+
+@ValidateClass()
+export class AsyncMethods {
+    async asyncMethod(@AssertType() body: { test: string }): Promise<boolean> {
+        return true
+    }
+    async asyncMethodNoExplicitReturn(@AssertType() body: { test: string }) {
+        return true
+    }
+    promiseReturnMethod(@AssertType() body: { test: string }): Promise<boolean> {
+        return Promise.resolve(true)
+    }
+    async asyncOverride(@AssertType({ async: false }) body: { test: string }): Promise<boolean> {
+        return true
+    }
+    promiseOrOtherReturnMethod(@AssertType() body: { test: string }): Promise<boolean> | boolean{
+        return Promise.resolve(true)
+    }
+}
+

test/issue-104.ts

@@ -0,0 +1,25 @@
+import * as assert from 'assert';
+import {AsyncMethods} from '../test-fixtures/issue-104';
+
+describe('@ValidateClass(), @AssertType()', () => {
+    it('should return rejected promise for async methods', () => {
+        const instance = new AsyncMethods()
+        assert.rejects(instance.asyncMethod({invalid: 123} as any))
+    })
+    it('should return rejected promise for async methods with not explicit return type', () => {
+        const instance = new AsyncMethods()
+        assert.rejects(instance.asyncMethodNoExplicitReturn({invalid: 123} as any))
+    })
+    it('should return rejected promise for methods returning promise', () => {
+        const instance = new AsyncMethods()
+        assert.rejects(instance.promiseReturnMethod({invalid: 123} as any))
+    })
+    it('should throw synchronously if { async: false } option is set', () => {
+        const instance = new AsyncMethods()
+        assert.throws(() => instance.asyncOverride({invalid: 123} as any))
+    })
+    it('should throw synchronously method may return something other than promise', () => {
+        const instance = new AsyncMethods()
+        assert.throws(() => instance.promiseOrOtherReturnMethod({invalid: 123} as any))
+    })
+})

test/issue-16.ts

@@ -37,6 +37,7 @@ describe('visitor', () => {
                     functionBehavior: 'error',
                     shortCircuit: false,
                     disallowSuperfluousObjectProperties: false,
+                    transformNonNullExpressions: false,
                     emitDetailedErrors: 'auto'
                 },
                 typeMapperStack: [],
@@ -63,6 +64,7 @@ describe('visitor', () => {
                     functionBehavior: 'error',
                     shortCircuit: false,
                     disallowSuperfluousObjectProperties: false,
+                    transformNonNullExpressions: false,
                     emitDetailedErrors: 'auto'
                 },
                 typeMapperStack: [],
@@ -93,6 +95,7 @@ describe('visitor', () => {
                 functionBehavior: 'error',
                 shortCircuit: false,
                 disallowSuperfluousObjectProperties: false,
+                transformNonNullExpressions: false,
                 emitDetailedErrors: 'auto'
             },
             typeMapperStack: [],
@@ -122,6 +125,7 @@ describe('visitor', () => {
                 functionBehavior: 'error',
                 shortCircuit: false,
                 disallowSuperfluousObjectProperties: false,
+                transformNonNullExpressions: false,
                 emitDetailedErrors: 'auto'
             },
             typeMapperStack: [],
@@ -151,6 +155,7 @@ describe('visitor', () => {
                 functionBehavior: 'error',
                 shortCircuit: false,
                 disallowSuperfluousObjectProperties: false,
+                transformNonNullExpressions: false,
                 emitDetailedErrors: 'auto'
             },
             typeMapperStack: [],

test/issue-27.ts

@@ -35,6 +35,7 @@ describe('visitor', () => {
                 functionBehavior: 'error',
                 shortCircuit: false,
                 disallowSuperfluousObjectProperties: false,
+                transformNonNullExpressions: false,
                 emitDetailedErrors: 'auto'
             },
             typeMapperStack: [],