Misc Fixes (#9)

* Fixed required annotation error message
* Making a return type optional (assumes void) and fixing validation rule for void returns
* Disable camel case directive name rule
* Fix descriptions over namespaces, imports, directives, interfaces and roles
* Make parameters parenthesis options for directive definitions
* Added parseType
* Switch on kind improvement
* Added annotation callback
* novisit annotation for types and enums
* Operation returns void validation fix
* Required field from type in valid annotation check

Author: pkedy

src/ast/definitions.ts

@@ -49,8 +49,11 @@ export class NamespaceDefinition extends AbstractNode {
     this.annotations = annotations || [];
   }
 
-  directive(name: string): Annotation | undefined {
-    return getAnnotation(name, this.annotations);
+  annotation(
+    name: string,
+    callback?: (annotation: Annotation) => void
+  ): Annotation | undefined {
+    return getAnnotation(name, this.annotations, callback);
   }
 
   public accept(context: Context, visitor: Visitor): void {
@@ -82,8 +85,11 @@ export class ImportDefinition extends AbstractNode {
     this.annotations = annotations || [];
   }
 
-  directive(name: string): Annotation | undefined {
-    return getAnnotation(name, this.annotations);
+  annotation(
+    name: string,
+    callback?: (annotation: Annotation) => void
+  ): Annotation | undefined {
+    return getAnnotation(name, this.annotations, callback);
   }
 
   public accept(context: Context, visitor: Visitor): void {
@@ -115,8 +121,11 @@ export class TypeDefinition extends AbstractNode {
     this.fields = fields;
   }
 
-  annotation(name: string): Annotation | undefined {
-    return getAnnotation(name, this.annotations);
+  annotation(
+    name: string,
+    callback?: (annotation: Annotation) => void
+  ): Annotation | undefined {
+    return getAnnotation(name, this.annotations, callback);
   }
 
   public accept(context: Context, visitor: Visitor): void {
@@ -183,8 +192,11 @@ export class OperationDefinition extends AbstractNode {
     return mp;
   }
 
-  annotaton(name: string): Annotation | undefined {
-    return getAnnotation(name, this.annotations);
+  annotation(
+    name: string,
+    callback?: (annotation: Annotation) => void
+  ): Annotation | undefined {
+    return getAnnotation(name, this.annotations, callback);
   }
 
   public accept(context: Context, visitor: Visitor): void {
@@ -230,8 +242,11 @@ export abstract class ValuedDefinition extends AbstractNode {
     this.annotations = annotations;
   }
 
-  directive(name: string): Annotation | undefined {
-    return getAnnotation(name, this.annotations);
+  annotation(
+    name: string,
+    callback?: (annotation: Annotation) => void
+  ): Annotation | undefined {
+    return getAnnotation(name, this.annotations, callback);
   }
 }
 
@@ -300,8 +315,11 @@ export class InterfaceDefinition extends AbstractNode implements Definition {
     this.annotations = annotations || [];
   }
 
-  directive(name: string): Annotation | undefined {
-    return getAnnotation(name, this.annotations);
+  annotation(
+    name: string,
+    callback?: (annotation: Annotation) => void
+  ): Annotation | undefined {
+    return getAnnotation(name, this.annotations, callback);
   }
 
   public accept(context: Context, visitor: Visitor): void {
@@ -340,8 +358,11 @@ export class RoleDefinition extends AbstractNode implements Definition {
     this.annotations = annotations || [];
   }
 
-  directive(name: string): Annotation | undefined {
-    return getAnnotation(name, this.annotations);
+  annotation(
+    name: string,
+    callback?: (annotation: Annotation) => void
+  ): Annotation | undefined {
+    return getAnnotation(name, this.annotations, callback);
   }
 
   public accept(context: Context, visitor: Visitor): void {
@@ -380,8 +401,11 @@ export class UnionDefinition extends AbstractNode implements Definition {
     this.types = types;
   }
 
-  directive(name: string): Annotation | undefined {
-    return getAnnotation(name, this.annotations);
+  annotation(
+    name: string,
+    callback?: (annotation: Annotation) => void
+  ): Annotation | undefined {
+    return getAnnotation(name, this.annotations, callback);
   }
 
   public accept(context: Context, visitor: Visitor): void {
@@ -410,8 +434,11 @@ export class EnumDefinition extends AbstractNode implements Definition {
     this.values = values;
   }
 
-  directive(name: string): Annotation | undefined {
-    return getAnnotation(name, this.annotations);
+  annotation(
+    name: string,
+    callback?: (annotation: Annotation) => void
+  ): Annotation | undefined {
+    return getAnnotation(name, this.annotations, callback);
   }
 
   public accept(context: Context, visitor: Visitor): void {
@@ -452,8 +479,11 @@ export class EnumValueDefinition extends AbstractNode implements Definition {
     this.annotations = annotations;
   }
 
-  directive(name: string): Annotation | undefined {
-    return getAnnotation(name, this.annotations);
+  annotation(
+    name: string,
+    callback?: (annotation: Annotation) => void
+  ): Annotation | undefined {
+    return getAnnotation(name, this.annotations, callback);
   }
 
   public accept(context: Context, visitor: Visitor): void {
@@ -533,13 +563,17 @@ function visitAnnotations(
 
 function getAnnotation(
   name: string,
-  annotations?: Annotation[]
+  annotations?: Annotation[],
+  callback?: (annotation: Annotation) => void
 ): Annotation | undefined {
   if (annotations == undefined) {
     return undefined;
   }
   for (let a of annotations!) {
     if (a.name.value === name) {
+      if (callback != undefined) {
+        callback(a);
+      }
       return a;
     }
   }

src/ast/document.ts

@@ -42,7 +42,9 @@ export class Document extends AbstractNode {
 
     visitor.visitTypesBefore(context);
     context.types.map((type) => {
-      type.accept(context.clone({ type: type }), visitor);
+      if (!type.annotation("novisit")) {
+        type.accept(context.clone({ type: type }), visitor);
+      }
     });
     visitor.visitTypesAfter(context);
 
@@ -54,7 +56,9 @@ export class Document extends AbstractNode {
 
     visitor.visitEnumsBefore(context);
     context.enums.map((enumDef) => {
-      enumDef.accept(context.clone({ enumDef: enumDef }), visitor);
+      if (!enumDef.annotation("novisit")) {
+        enumDef.accept(context.clone({ enumDef: enumDef }), visitor);
+      }
     });
     visitor.visitEnumsAfter(context);
 

src/ast/nodes.ts

@@ -57,12 +57,12 @@ export class Annotation extends AbstractNode {
     this.arguments = args || [];
   }
 
-  toObject(): { [k: string]: any } {
+  convert<T>(): T {
     let obj: { [k: string]: any } = {};
     this.arguments.map((arg) => {
       obj[arg.name.value] = arg.value.getValue();
     });
-    return obj;
+    return obj as T;
   }
 
   public accept(context: Context, visitor: Visitor): void {

src/ast/visitor.ts

@@ -197,36 +197,36 @@ export class Context {
 
   private parseDocument(): void {
     this.document!.definitions.forEach((value) => {
-      switch (true) {
-        case value.isKind(Kind.NamespaceDefinition):
+      switch (value.getKind()) {
+        case Kind.NamespaceDefinition:
           this.namespace = value as NamespaceDefinition;
           break;
-        case value.isKind(Kind.DirectiveDefinition):
+        case Kind.DirectiveDefinition:
           const directive = value as DirectiveDefinition;
           this.directives.push(directive);
           this.directiveMap.set(directive.name.value, directive);
           break;
-        case value.isKind(Kind.ImportDefinition):
+        case Kind.ImportDefinition:
           this.imports.push(value as ImportDefinition);
           break;
-        case value.isKind(Kind.InterfaceDefinition):
+        case Kind.InterfaceDefinition:
           this.interface = value as InterfaceDefinition;
           break;
-        case value.isKind(Kind.RoleDefinition):
+        case Kind.RoleDefinition:
           const role = value as RoleDefinition;
           this.roles.push(role);
           break;
-        case value.isKind(Kind.TypeDefinition):
+        case Kind.TypeDefinition:
           const type = value as TypeDefinition;
           this.types.push(type);
           this.allTypes.set(type.name.value, type);
           break;
-        case value.isKind(Kind.EnumDefinition):
+        case Kind.EnumDefinition:
           const enumDef = value as EnumDefinition;
           this.enums.push(enumDef);
           this.allTypes.set(enumDef.name.value, enumDef);
           break;
-        case value.isKind(Kind.UnionDefinition):
+        case Kind.UnionDefinition:
           const union = value as UnionDefinition;
           this.unions.push(union);
           this.allTypes.set(union.name.value, union);