feat: consider array return type in visitor

lib/fixtures/fake-service-code.ts

@@ -47,3 +47,26 @@ class UserService {
     throw new Error('not implemented');
   }
 }`;
+
+export const arrayResponseBodyServiceCode = `
+import { HttpInterface, GetExchange } from '@r2don/nest-http-interface';
+
+class ResponseClass {}
+
+@HttpInterface()
+class UserService {
+  @GetExchange()
+  async getUsers(): Promise<ResponseClass[]> {
+    throw new Error('not implemented');
+  }
+
+  @GetExchange()
+  async getUserList(): Promise<Array<ResponseClass>> {
+    throw new Error('not implemented');
+  }
+
+  @GetExchange()
+  async getUsersReadonly(): Promise<readonly ResponseClass[]> {
+    throw new Error('not implemented');
+  }
+}`;

lib/plugin/visitors/__snapshots__/http-interface.visitor.spec.ts.snap

@@ -1,5 +1,38 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
+exports[`HttpInterfaceVisitor > should handle array return type 1`] = `
+"import { HttpInterface, GetExchange } from '@r2don/nest-http-interface';
+class ResponseClass {
+}
+let UserService = class UserService {
+    async getUsers() {
+        throw new Error('not implemented');
+    }
+    async getUserList() {
+        throw new Error('not implemented');
+    }
+    async getUsersReadonly() {
+        throw new Error('not implemented');
+    }
+};
+__decorate([
+    GetExchange(),
+    ResponseBody(ResponseClass)
+], UserService.prototype, \\"getUsers\\", null);
+__decorate([
+    GetExchange(),
+    ResponseBody(ResponseClass)
+], UserService.prototype, \\"getUserList\\", null);
+__decorate([
+    GetExchange(),
+    ResponseBody(ResponseClass)
+], UserService.prototype, \\"getUsersReadonly\\", null);
+UserService = __decorate([
+    HttpInterface()
+], UserService);
+"
+`;
+
 exports[`HttpInterfaceVisitor > should ignore if file name is not match 1`] = `
 "import { HttpInterface, GraphQLExchange } from '@r2don/nest-http-interface';
 class ResponseClass {

lib/plugin/visitors/http-interface.visitor.spec.ts

@@ -5,6 +5,7 @@ import {
   hasResponseBodyServiceCode,
   needResponseBodyServiceCode,
   notPromiseServiceCode,
+  arrayResponseBodyServiceCode,
 } from '../../fixtures/fake-service-code';
 import { before } from '../compiler-plugin';
 
@@ -103,4 +104,22 @@ describe('HttpInterfaceVisitor', () => {
     // then
     expect(result.outputText).toMatchSnapshot();
   });
+
+  test('should handle array return type', () => {
+    // given
+    const filename = 'text.service.ts';
+    const fakeProgram = ts.createProgram([filename], compilerOptions);
+
+    // when
+    const result = ts.transpileModule(arrayResponseBodyServiceCode, {
+      compilerOptions,
+      fileName: filename,
+      transformers: {
+        before: [before({}, fakeProgram)],
+      },
+    });
+
+    // then
+    expect(result.outputText).toMatchSnapshot();
+  });
 });

lib/plugin/visitors/http-interface.visitor.ts

@@ -107,7 +107,7 @@ export class HttpInterfaceVisitor {
       return undefined;
     }
 
-    const innerType = node.type.typeArguments?.[0];
+    const innerType = this.getInnerType(node.type.typeArguments?.[0]);
     if (
       innerType == null ||
       !ts.isTypeReferenceNode(innerType) ||
@@ -119,6 +119,34 @@ export class HttpInterfaceVisitor {
     return innerType.typeName.text;
   }
 
+  private getInnerType(node?: ts.TypeNode): ts.TypeNode | undefined {
+    /* c8 ignore next 3 */
+    if (node == null) {
+      return undefined;
+    }
+
+    if (ts.isArrayTypeNode(node)) {
+      return this.getInnerType(node.elementType);
+    }
+
+    if (
+      ts.isTypeReferenceNode(node) &&
+      ts.isIdentifier(node.typeName) &&
+      node.typeName.text === 'Array'
+    ) {
+      return this.getInnerType(node.typeArguments?.[0]);
+    }
+
+    if (
+      ts.isTypeOperatorNode(node) &&
+      node.operator === ts.SyntaxKind.ReadonlyKeyword
+    ) {
+      return this.getInnerType(node.type);
+    }
+
+    return node;
+  }
+
   private isExchangeMethod(
     member: ts.ClassElement,
   ): member is ts.MethodDeclaration {