Merge pull request #108 from cauthmann/master

Add an option to generate code without detailed error messages

Author: woutervh-

Diff for: README.md

@@ -138,6 +138,7 @@ There are some options to configure the transformer.
 | `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,7 +153,8 @@ If you are using `ttypescript`, you can include the options in your `tsconfig.js
                 "ignoreMethods": true,
                 "functionBehavior": "ignore",
                 "disallowSuperfluousObjectProperties": true,
-                "transformNonNullExpressions": true
+                "transformNonNullExpressions": true,
+                "emitDetailedErrors": "auto"
             }
         ]
     }

Diff for: index.js

@@ -19,6 +19,8 @@ function inputObjectAtPath(path, inputObject) {
 }
 
 function appendInputToErrorMessage(message, path, inputObject) {
+    if (message === undefined)
+        return 'validation error';
     const foundInputObject = inputObjectAtPath(path, inputObject);
     try {
         return message + ', found: ' + require('util').inspect(foundInputObject);

Diff for: src/transform-inline/transform-node.ts

@@ -9,16 +9,25 @@ function createArrowFunction(type: ts.Type, rootName: string, optional: boolean,
     const functionMap: VisitorContext['functionMap'] = new Map();
     const functionNames: VisitorContext['functionNames'] = new Set();
     const typeIdMap: VisitorContext['typeIdMap'] = new Map();
-    const visitorContext = { ...partialVisitorContext, functionNames, functionMap, typeIdMap };
+    const visitorContext: VisitorContext = { ...partialVisitorContext, functionNames, functionMap, typeIdMap };
+    const emitDetailedErrors = !!visitorContext.options.emitDetailedErrors;
     const functionName = partialVisitorContext.options.shortCircuit
         ? visitShortCircuit(visitorContext)
         : (optional
             ? visitUndefinedOrType(type, visitorContext)
             : visitType(type, visitorContext)
         );
 
-    const errorIdentifier = ts.createIdentifier('error');
-    const declarations = sliceMapValues(functionMap);
+    const variableDeclarations: ts.VariableStatement[] = [];
+    if (emitDetailedErrors) {
+        variableDeclarations.push(
+            ts.createVariableStatement(
+                [ts.createModifier(ts.SyntaxKind.ConstKeyword)],
+                [ts.createVariableDeclaration(VisitorUtils.pathIdentifier, undefined, ts.createArrayLiteral([ts.createStringLiteral(rootName)]))]
+            )
+        );
+    }
+    const functionDeclarations = sliceMapValues(functionMap);
 
     return ts.createArrowFunction(
         undefined,
@@ -36,16 +45,9 @@ function createArrowFunction(type: ts.Type, rootName: string, optional: boolean,
         undefined,
         undefined,
         ts.createBlock([
-            ts.createVariableStatement(
-                [ts.createModifier(ts.SyntaxKind.ConstKeyword)],
-                [ts.createVariableDeclaration(VisitorUtils.pathIdentifier, undefined, ts.createArrayLiteral([ts.createStringLiteral(rootName)]))]
-            ),
-            ...declarations,
-            ts.createVariableStatement(
-                [ts.createModifier(ts.SyntaxKind.ConstKeyword)],
-                [ts.createVariableDeclaration(errorIdentifier, undefined, ts.createCall(ts.createIdentifier(functionName), undefined, [VisitorUtils.objectIdentifier]))]
-            ),
-            ts.createReturn(errorIdentifier)
+            ...variableDeclarations,
+            ...functionDeclarations,
+            ts.createReturn(ts.createCall(ts.createIdentifier(functionName), undefined, [VisitorUtils.objectIdentifier]))
         ])
     );
 }
@@ -106,6 +108,8 @@ export function transformNode(node: ts.Node, visitorContext: PartialVisitorConte
         ) {
             const name = visitorContext.checker.getTypeAtLocation(signature.declaration).symbol.name;
             const isEquals = name === 'equals' || name === 'createEquals' || name === 'assertEquals' || name === 'createAssertEquals';
+            const isAssert = name === 'assertEquals' || name === 'assertType' || name === 'createAssertEquals' || name === 'createAssertType';
+            const emitDetailedErrors = visitorContext.options.emitDetailedErrors === 'auto' ? isAssert : visitorContext.options.emitDetailedErrors;
 
             const typeArgument = node.typeArguments[0];
             const type = visitorContext.checker.getTypeFromTypeNode(typeArgument);
@@ -117,7 +121,8 @@ export function transformNode(node: ts.Node, visitorContext: PartialVisitorConte
                     ...visitorContext,
                     options: {
                         ...visitorContext.options,
-                        disallowSuperfluousObjectProperties: isEquals || visitorContext.options.disallowSuperfluousObjectProperties
+                        disallowSuperfluousObjectProperties: isEquals || visitorContext.options.disallowSuperfluousObjectProperties,
+                        emitDetailedErrors
                     }
                 }
             );

Diff for: src/transform-inline/transformer.ts

@@ -18,6 +18,15 @@ function getFunctionBehavior(options?: { [Key: string]: unknown }): PartialVisit
     return 'error';
 }
 
+function getEmitDetailedErrors(options?: { [Key: string]: unknown }): PartialVisitorContext['options']['emitDetailedErrors'] {
+    if (options) {
+        if (options.emitDetailedErrors === 'auto' || typeof options.emitDetailedErrors === 'boolean') {
+            return options.emitDetailedErrors;
+        }
+    }
+    return 'auto';
+}
+
 export default function transformer(program: ts.Program, options?: { [Key: string]: unknown }): ts.TransformerFactory<ts.SourceFile> {
     if (options && options.verbose) {
         console.log(`typescript-is: transforming program with ${program.getSourceFiles().length} source files; using TypeScript ${ts.version}.`);
@@ -33,7 +42,8 @@ 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)
+            transformNonNullExpressions: !!(options && options.transformNonNullExpressions),
+            emitDetailedErrors: getEmitDetailedErrors(options)
         },
         typeMapperStack: [],
         previousTypeReference: null

Diff for: src/transform-inline/visitor-context.d.ts

@@ -7,6 +7,7 @@ interface Options {
     functionBehavior: 'error' | 'ignore' | 'basic';
     disallowSuperfluousObjectProperties: boolean;
     transformNonNullExpressions: boolean;
+    emitDetailedErrors: boolean | 'auto';
 }
 
 export interface VisitorContext extends PartialVisitorContext {

Diff for: src/transform-inline/visitor-keyof.ts

@@ -60,7 +60,8 @@ function visitRegularObjectType(type: ts.ObjectType, visitorContext: VisitorCont
             return VisitorUtils.createAssertionFunction(
                 condition,
                 { type: 'object-keyof', properties: names },
-                name
+                name,
+                visitorContext
             );
         });
     }