Feature/methods

test/programs/method-extreme/main.ts

@@ -0,0 +1,3 @@
+interface MyObject {
+  setTime?<T extends Array<string> & {name: {first: string, last: string}}, T2>(d: {name: string, test: number} | {name: {first: string, last: string}}, someParam?: T2): Array<T>;
+}

test/programs/method-extreme/schema.json

@@ -0,0 +1,93 @@
+{
+  "type": "object",
+  "properties": {
+    "setTime": {
+      "parameters": [
+        {
+          "name": "d",
+          "type": "union",
+          "typeArguments": [
+            {
+              "type": "object",
+              "properties": {
+                "name": {
+                  "type": "string"
+                },
+                "test": {
+                  "type": "number"
+                }
+              }
+            },
+            {
+              "type": "object",
+              "properties": {
+                "name": {
+                  "type": "object",
+                  "properties": {
+                    "first": {
+                      "type": "string"
+                    },
+                    "last": {
+                      "type": "string"
+                    }
+                  }
+                }
+              }
+            }
+          ]
+        },
+        {
+          "name": "someParam",
+          "optional": true,
+          "type": "T2"
+        }
+      ],
+      "typeParameters": [
+        {
+          "name": "T",
+          "constraint": {
+            "type": "intersection",
+            "typeArguments": [
+              {
+                "type": "Array",
+                "typeArguments": [
+                  {
+                    "type": "string"
+                  }
+                ]
+              },
+              {
+                "type": "object",
+                "properties": {
+                  "name": {
+                    "type": "object",
+                    "properties": {
+                      "first": {
+                        "type": "string"
+                      },
+                      "last": {
+                        "type": "string"
+                      }
+                    }
+                  }
+                }
+              }
+            ]
+          }
+        },
+        {
+          "name": "T2"
+        }
+      ],
+      "type": "object",
+      "returnType": "Array",
+      "returnTypeArguments": [
+        {
+          "type": "T"
+        }
+      ],
+      "optional": true
+    }
+  },
+  "$schema": "http://json-schema.org/draft-04/schema#"
+}

test/programs/method-simple/main.ts

@@ -0,0 +1,3 @@
+interface MyObject {
+  setTime(d: string): void;
+}

test/programs/method-simple/schema.json

@@ -0,0 +1,18 @@
+{
+  "type": "object",
+  "properties": {
+    "setTime": {
+      "parameters": [
+        {
+          "name": "d",
+          "type": "string"
+        }
+      ],
+      "type": "object"
+    }
+  },
+  "required": [
+    "setTime"
+  ],
+  "$schema": "http://json-schema.org/draft-04/schema#"
+}

test/schema.test.ts

@@ -82,6 +82,9 @@ describe("schema", () => {
     // not supported right now
     // assertSchema("module-interface-deep", "main.ts", "Def");
 
+    assertSchema("method-extreme", "main.ts", "MyObject");
+    assertSchema("method-simple", "main.ts", "MyObject");
+
     assertSchema("enums-string", "main.ts", "MyObject");
     assertSchema("enums-number", "main.ts", "MyObject");
     assertSchema("enums-number-initialized", "main.ts", "Enum");

typescript-json-schema.ts

@@ -51,6 +51,18 @@ export type PartialArgs = Partial<Args>;
 
 export type PrimitiveType = number | boolean | string | null;
 
+export type TypeArgument = {
+    type?: string,
+    typeArguments?: TypeArgument[],
+    properties?: {},
+    constraint?: TypeArgument
+};
+
+export type Parameter = TypeArgument & {
+    name: string,
+    optional?: boolean
+};
+
 export type Definition = {
     $ref?: string,
     description?: string,
@@ -59,6 +71,7 @@ export type Definition = {
     anyOf?: Definition[],
     title?: string,
     type?: string | string[],
+    typeArguments?: TypeArgument[],
     definitions?: {[key: string]: any},
     format?: string,
     items?: Definition,
@@ -73,6 +86,11 @@ export type Definition = {
     propertyOrder?: string[],
     properties?: {},
     defaultProperties?: string[],
+    parameters?: Parameter[]
+    returnType?: string,
+    returnTypeArguments?: TypeArgument[],
+    typeParameters?: TypeArgument[],
+    optional?: boolean,
 
     typeof?: "function"
 };
@@ -502,6 +520,146 @@ export class JsonSchemaGenerator {
         return definition;
     }
 
+    private typeIsTypeReference(type: ts.Node): type is ts.TypeReferenceNode {
+        return type.kind === ts.SyntaxKind.TypeReference;
+    }
+
+    private typeIsUnionType(type: ts.Node): type is ts.UnionTypeNode {
+        return type.kind === ts.SyntaxKind.UnionType;
+    }
+
+    private typeIsIntersectionType(type: ts.Node): type is ts.IntersectionTypeNode {
+        return type.kind === ts.SyntaxKind.IntersectionType;
+    }
+
+    private typeIsTypeLiteral(type: ts.Node): type is ts.TypeLiteralNode {
+        return type.kind === ts.SyntaxKind.TypeLiteral;
+    }
+
+    private typeElementIsPropertySignature(type: ts.Node): type is ts.PropertySignature {
+        return type.kind === ts.SyntaxKind.PropertySignature;
+    }
+
+    private declarationIsPrameterDeclaration(declaration: ts.Declaration): declaration is ts.ParameterDeclaration {
+        return declaration.kind === ts.SyntaxKind.Parameter;
+    }
+
+    private declarationIsTypeParameterDeclaration(declaration: ts.Declaration): declaration is ts.TypeParameterDeclaration {
+        return declaration.kind === ts.SyntaxKind.TypeParameter;
+    }
+
+    private getTypeDescription(type?: ts.Node): TypeArgument {
+        const typeObject: TypeArgument = {};
+
+        if (!type) {
+            return typeObject;
+        }
+
+        if (this.typeIsUnionType(type)) {
+            typeObject.type = "union";
+            typeObject.typeArguments = type.types.map((subType: ts.TypeNode) => {
+                return this.getTypeDescription(subType);
+            });
+        } else if (this.typeIsIntersectionType(type)) {
+            typeObject.type = "intersection";
+            typeObject.typeArguments = type.types.map((subType: ts.TypeNode) => {
+                return this.getTypeDescription(subType);
+            });
+        } else if (this.typeIsTypeReference(type)) {
+            typeObject.type = type.typeName.getText();
+            if (type.typeArguments && type.typeArguments.length > 0) {
+                typeObject.typeArguments = type.typeArguments.map((typeArgument: ts.TypeNode) => {
+                    return this.getTypeDescription(typeArgument);
+                });
+            }
+        } else if (type.kind === ts.SyntaxKind.StringKeyword) {
+            typeObject.type = "string";
+        } else if (type.kind === ts.SyntaxKind.NumberKeyword) {
+            typeObject.type = "number";
+        } else if (type.kind === ts.SyntaxKind.BooleanKeyword) {
+            typeObject.type = "boolean";
+        } else if (this.typeIsTypeLiteral(type)) {
+            typeObject.type = "object";
+            typeObject.properties = {};
+            for (let i = 0; i < type.members.length; i++) {
+                const typeMember: ts.TypeElement = type.members[i];
+                if (this.typeElementIsPropertySignature(typeMember)) {
+                    typeObject.properties[typeMember.name.getText()] = this.getTypeDescription(typeMember.type);
+                }
+            }
+        }
+
+        return typeObject;
+    }
+
+    private getMethodParameters(parameters: ts.NodeArray<ts.Declaration>): Array<Parameter> {
+        return parameters.sort((param1, param2) => {
+            return param1.pos - param2.pos;
+        })
+        .map((parameter: ts.Declaration) => {
+            return this.getMethodParameter(parameter);
+        });
+    }
+
+    private getMethodParameter(parameter: ts.Declaration) {
+        let typeObject: TypeArgument = {};
+        if (this.declarationIsPrameterDeclaration(parameter)) {
+            typeObject = this.getTypeDescription(parameter.type);
+        } else if (this.declarationIsTypeParameterDeclaration(parameter)) {
+            typeObject = this.getTypeDescription(parameter);
+        } else {
+            return {name: "__name_not_found__"};
+        }
+
+        const parameterObject: Parameter = {
+            name: parameter.name.getText(),
+        };
+
+        if (this.declarationIsPrameterDeclaration(parameter) && parameter.questionToken && parameter.questionToken.kind === ts.SyntaxKind.QuestionToken) {
+            parameterObject.optional = true;
+        }
+
+        if (this.declarationIsTypeParameterDeclaration(parameter) && parameter.constraint) {
+            parameterObject.constraint = this.getTypeDescription(parameter.constraint);
+        }
+
+        if (typeObject.type) {
+            parameterObject.type = typeObject.type;
+        }
+
+        if (typeObject.typeArguments) {
+            parameterObject.typeArguments = typeObject.typeArguments;
+        }
+
+        return parameterObject;
+    }
+
+    private getMethodDefinition(methodType: ts.Type, definition: Definition): Definition {
+        definition.type = "object";
+
+        const declaration: ts.MethodDeclaration = <ts.MethodDeclaration> methodType.getSymbol().getDeclarations()[0];
+        definition.parameters = this.getMethodParameters(declaration.parameters);
+        if (declaration.typeParameters) {
+            definition.typeParameters = this.getMethodParameters(declaration.typeParameters);
+        }
+
+        const returnType: TypeArgument = this.getTypeDescription(declaration.type);
+        if (returnType.type) {
+            definition.returnType = returnType.type;
+        }
+
+        if (returnType.typeArguments) {
+            definition.returnTypeArguments = returnType.typeArguments;
+        }
+
+        if (declaration.questionToken && declaration.questionToken.kind === ts.SyntaxKind.QuestionToken) {
+            definition.optional = true;
+        }
+        // The description describes the return-type, which is misleading, because one would expect it to describe the method itsef
+        delete definition.description;
+        return definition;
+    }
+
     private getClassDefinition(clazzType: ts.Type, tc: ts.TypeChecker, definition: Definition): Definition {
         const node = clazzType.getSymbol().getDeclarations()[0];
         if (this.args.useTypeOfKeyword && node.kind === ts.SyntaxKind.FunctionType) {
@@ -766,6 +924,8 @@ export class JsonSchemaGenerator {
                     // {} is TypeLiteral with no members. Need special case because it doesn't have declarations.
                     definition.type = "object";
                     definition.properties = {};
+                } else if (symbol && symbol.getDeclarations()[0].kind === ts.SyntaxKind.MethodSignature) {
+                    this.getMethodDefinition(typ, definition);
                 } else {
                     this.getClassDefinition(typ, tc, definition);
                 }