fix: resolve toJSON in getModelReference()

Author: Eywek

src/metadataGeneration/typeResolver.ts

@@ -254,29 +254,6 @@ 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;
-
-        let nodeType = declaration.type;
-        if (!nodeType) {
-          const typeChecker = this.current.typeChecker;
-          const signature = typeChecker.getSignatureFromDeclaration(declaration);
-          const implicitType = typeChecker.getReturnTypeOfSignature(signature!);
-          nodeType = typeChecker.typeToTypeNode(implicitType) as ts.TypeNode;
-        }
-        const type = new TypeResolver(nodeType, this.current).resolve();
-        const referenceType: Tsoa.ReferenceType = {
-          refName: typeReference.getText(),
-          dataType: 'refAlias',
-          type,
-          validators: {},
-        };
-        this.current.AddReferenceType(referenceType);
-        return referenceType;
-      }
-
       if (this.context[typeReference.typeName.text]) {
         return new TypeResolver(this.context[typeReference.typeName.text], this.current, this.parentNode, this.context).resolve();
       }
@@ -478,15 +455,45 @@ export class TypeResolver {
   }
 
   private getModelReference(modelType: ts.InterfaceDeclaration | ts.ClassDeclaration, name: string) {
+    const example = this.getNodeExample(modelType);
+    const description = this.getNodeDescription(modelType);
+
+    // Handle toJSON methods
+    let toJSON: ts.ClassElement | ts.TypeElement | undefined;
+    if (ts.isClassDeclaration(modelType)) {
+      toJSON = modelType.members.find(member => member.name && member.name.getText() === 'toJSON');
+    } else {
+      toJSON = modelType.members.find(member => member.name && member.name.getText() === 'toJSON');
+    }
+
+    if (toJSON && (ts.isMethodDeclaration(toJSON) || ts.isMethodSignature(toJSON))) {
+      let nodeType = toJSON.type;
+      if (!nodeType) {
+        const typeChecker = this.current.typeChecker;
+        const signature = typeChecker.getSignatureFromDeclaration(toJSON);
+        const implicitType = typeChecker.getReturnTypeOfSignature(signature!);
+        nodeType = typeChecker.typeToTypeNode(implicitType) as ts.TypeNode;
+      }
+      const type = new TypeResolver(nodeType, this.current).resolve();
+      const referenceType: Tsoa.ReferenceType = {
+        refName: this.getRefTypeName(name),
+        dataType: 'refAlias',
+        description,
+        type,
+        validators: {},
+        ...(example && { example }),
+      };
+      return referenceType;
+    }
+
     const properties = this.getModelProperties(modelType);
     const additionalProperties = this.getModelAdditionalProperties(modelType);
     const inheritedProperties = this.getModelInheritedProperties(modelType) || [];
-    const example = this.getNodeExample(modelType);
 
     const referenceType: Tsoa.ReferenceType = {
       additionalProperties,
       dataType: 'refObject',
-      description: this.getNodeDescription(modelType),
+      description,
       properties: inheritedProperties,
       refName: this.getRefTypeName(name),
       ...(example && { example }),

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, GetterClass, TestClassModel, TestModel, TestSubModel } from '../testModel';
+import { GenericModel, GetterClass, TestClassModel, TestModel, TestSubModel, GetterInterface } from '../testModel';
 import { ModelService } from './../services/modelService';
 
 @Route('GetTest')
@@ -63,6 +63,11 @@ export class GetTestController extends Controller {
     return new GetterClass();
   }
 
+  @Get('GetterInterface')
+  public async getGetterInterface(): Promise<GetterInterface> {
+    return {} as GetterInterface;
+  }
+
   @Get('Multi')
   public async getMultipleModels(): Promise<TestModel[]> {
     return [new ModelService().getModel(), new ModelService().getModel(), new ModelService().getModel()];

tests/fixtures/testModel.ts

@@ -634,6 +634,10 @@ export class GetterClass {
   }
 }
 
+export interface GetterInterface {
+  toJSON(): { foo: string };
+}
+
 export interface GenericModel<T = string> {
   result: T;
   union?: T | string;

tests/unit/swagger/schemaDetails3.spec.ts

@@ -864,6 +864,25 @@ describe('Definition generation for OpenAPI 3.0.0', () => {
               type: 'object',
             });
 
+            const getterInterface = getComponentSchema('GetterInterface', currentSpec);
+            expect(getterInterface).to.deep.eq({
+              properties: {
+                foo: {
+                  type: 'string',
+                  description: undefined,
+                  example: undefined,
+                  format: undefined,
+                  default: undefined,
+                },
+              },
+              required: ['foo'],
+              type: 'object',
+              default: undefined,
+              example: undefined,
+              format: undefined,
+              description: undefined,
+            });
+
             const omit = getComponentSchema('Omit_ErrorResponseModel.status_', currentSpec);
             expect(omit).to.deep.eq(
               {