feat: wip implement toJSON scan

Author: Eywek

src/metadataGeneration/typeResolver.ts

@@ -254,6 +254,22 @@ export class TypeResolver {
         return stringMetaType;
       }
 
+      const type = this.current.typeChecker.getTypeFromTypeNode(this.typeNode);
+      const toJSON = this.current.typeChecker.getPropertyOfType(type, 'toJSON');
+      if (toJSON) {
+        const declaration = toJSON.declarations[0] as ts.MethodDeclaration;
+        const signature = this.current.typeChecker.getSignatureFromDeclaration(declaration);
+        const returnType = this.current.typeChecker.getReturnTypeOfSignature(signature!);
+        try {
+          const resolved = new TypeResolver(this.current.typeChecker.typeToTypeNode(returnType)!, this.current, this.parentNode, this.context).resolve() as Tsoa.ReferenceType;
+          resolved.refName = typeReference.getText();
+          this.current.AddReferenceType(resolved);
+          return resolved;
+        } catch {
+          // ignore methods
+        }
+      }
+
       if (this.context[typeReference.typeName.text]) {
         return new TypeResolver(this.context[typeReference.typeName.text], this.current, this.parentNode, this.context).resolve();
       }

tests/fixtures/controllers/getController.ts

@@ -1,7 +1,7 @@
 import { Readable } from 'stream';
 import { Controller, Example, Get, OperationId, Query, Request, Route, SuccessResponse, Tags } from '../../../src';
 import '../duplicateTestModel';
-import { GenericModel, TestClassModel, TestModel, TestSubModel } from '../testModel';
+import { GenericModel, GetterClass, TestClassModel, TestModel, TestSubModel } from '../testModel';
 import { ModelService } from './../services/modelService';
 
 @Route('GetTest')
@@ -58,6 +58,11 @@ export class GetTestController extends Controller {
     return new ModelService().getClassModel();
   }
 
+  @Get('GetterClass')
+  public async getGetterClass(): Promise<GetterClass> {
+    return new GetterClass();
+  }
+
   @Get('Multi')
   public async getMultipleModels(): Promise<TestModel[]> {
     return [new ModelService().getModel(), new ModelService().getModel(), new ModelService().getModel()];

tests/fixtures/testModel.ts

@@ -618,6 +618,18 @@ export class TestClassModel extends TestClassBaseModel {
   }
 }
 
+export class GetterClass {
+  public a: 'b';
+
+  get foo() {
+    return 'bar';
+  }
+
+  public toJSON() {
+    return Object.assign({}, { a: this.a }, { foo: this.foo });
+  }
+}
+
 export interface GenericModel<T = string> {
   result: T;
   union?: T | string;

tests/unit/swagger/definitionsGeneration/definitions.spec.ts

@@ -682,6 +682,18 @@ describe('Definition generation', () => {
               `for a schema linked by property ${propertyName}`,
             );
 
+            const getterClass = getValidatedDefinition('GetterClass', currentSpec);
+            expect(getterClass).to.deep.eq({
+              properties: {
+                a: { type: 'string', default: undefined, description: undefined, format: undefined, example: undefined, enum: ['b'], 'x-nullable': false },
+                foo: { type: 'string', default: undefined, description: undefined, format: undefined, example: undefined },
+              },
+              required: ['foo', 'a'],
+              type: 'object',
+              description: undefined,
+              additionalProperties: false,
+            });
+
             const omitHiddenReference = getValidatedDefinition('Pick_PrivateModel.Exclude_keyofPrivateModel.stringPropDec1__', currentSpec);
             expect(omitHiddenReference).to.deep.eq(
               {