refactor(plugin) remove nested types introspection, refactor

Nested types introspection was useless because runtime did not understand this code.
There is no way to use "anonymous" type literals in graphql schema

Add tests for replaceImportPath util, because current test suite didn't cover
all branches in it.

Author: timofei-iatsenko

lib/plugin/utils/plugin-utils.ts

@@ -99,11 +99,11 @@ export function isPromiseOrObservable(type: string) {
 
 export function replaceImportPath(typeReference: string, fileName: string) {
   if (!typeReference.includes('import')) {
-    return typeReference;
+    return { typeReference, importPath: null };
   }
-  let importPath = /\(\"([^)]).+(\")/.exec(typeReference)[0];
+  let importPath = /\("([^)]).+(")/.exec(typeReference)[0];
   if (!importPath) {
-    return undefined;
+    return { typeReference: undefined, importPath: null };
   }
   importPath = convertPath(importPath);
   importPath = importPath.slice(2, importPath.length - 1);
@@ -134,7 +134,9 @@ export function replaceImportPath(typeReference: string, fileName: string) {
   }
 
   typeReference = typeReference.replace(importPath, relativePath);
-  return typeReference.replace('import', 'require');
+  typeReference = typeReference.replace('import', 'require');
+
+  return { typeReference, importPath: relativePath };
 }
 
 export function isDynamicallyAdded(identifier: ts.Node) {

lib/plugin/visitors/model-class.visitor.ts

@@ -33,8 +33,6 @@ import {
 import { EnumMetadataValuesMapOptions } from '../../schema-builder/metadata';
 import { EnumOptions } from '../../type-factories';
 
-const importsToAddPerFile = new Map<string, Set<string>>();
-
 const ALLOWED_DECORATORS = [
   ObjectType.name,
   InterfaceType.name,
@@ -52,6 +50,8 @@ function capitalizeFirstLetter(word: string) {
 }
 
 export class ModelClassVisitor {
+  importsToAdd: Set<string>;
+
   inlineEnumsMap: { name: string; values: { [name: string]: string } }[];
   enumsMetadata: Map<ts.EnumDeclaration, EnumMetadata>;
   packageVarIdentifier: ts.Identifier;
@@ -65,7 +65,7 @@ export class ModelClassVisitor {
   ) {
     this.inlineEnumsMap = [];
     this.enumsMetadata = new Map();
-
+    this.importsToAdd = new Set<string>();
     this.isCommonJs = ctx.getCompilerOptions().module === ModuleKind.CommonJS;
 
     const typeChecker = program.getTypeChecker();
@@ -113,10 +113,8 @@ export class ModelClassVisitor {
       } else if (ts.isSourceFile(node)) {
         const visitedNode = ts.visitEachChild(node, visitNode, ctx);
 
-        const importStatements: ts.Statement[] = this.createEagerImports(
-          factory,
-          node.fileName,
-        );
+        const importStatements: ts.Statement[] =
+          this.createEagerImports(factory);
 
         const implicitEnumsStatements = this.createImplicitEnums(factory);
 
@@ -490,13 +488,7 @@ export class ModelClassVisitor {
       undefined,
       overrideType
         ? f.createIdentifier(overrideType)
-        : this.createTypePropertyAssignment(
-            f,
-            node.type,
-            typeChecker,
-            hostFilename,
-            pluginOptions,
-          ),
+        : this.getTypeUsingTypeChecker(f, node.type, typeChecker, hostFilename),
     );
 
     const description = pluginOptions.introspectComments
@@ -517,49 +509,23 @@ export class ModelClassVisitor {
     return objectLiteral;
   }
 
-  private createTypePropertyAssignment(
+  private getTypeUsingTypeChecker(
     f: ts.NodeFactory,
     node: ts.TypeNode,
     typeChecker: ts.TypeChecker,
     hostFilename: string,
-    pluginOptions?: PluginOptions,
   ) {
-    if (node) {
-      if (ts.isTypeLiteralNode(node)) {
-        const propertyAssignments = Array.from(node.members || []).map(
-          (member) => {
-            const literalExpr = this.createDecoratorObjectLiteralExpr(
-              f,
-              member as ts.PropertySignature,
-              typeChecker,
-              undefined,
-              hostFilename,
-              pluginOptions,
-            );
-            return f.createPropertyAssignment(
-              f.createIdentifier(member.name.getText()),
-              literalExpr,
-            );
-          },
-        );
-
-        return f.createParenthesizedExpression(
-          f.createObjectLiteralExpression(propertyAssignments),
-        );
-      } else if (ts.isUnionTypeNode(node)) {
-        const nullableType = findNullableTypeFromUnion(node, typeChecker);
-        const remainingTypes = node.types.filter(
-          (item) => item !== nullableType,
+    if (node && ts.isUnionTypeNode(node)) {
+      const nullableType = findNullableTypeFromUnion(node, typeChecker);
+      const remainingTypes = node.types.filter((item) => item !== nullableType);
+
+      if (remainingTypes.length === 1) {
+        return this.getTypeUsingTypeChecker(
+          f,
+          remainingTypes[0],
+          typeChecker,
+          hostFilename,
         );
-
-        if (remainingTypes.length === 1) {
-          return this.createTypePropertyAssignment(
-            f,
-            remainingTypes[0],
-            typeChecker,
-            hostFilename,
-          );
-        }
       }
     }
 
@@ -568,38 +534,31 @@ export class ModelClassVisitor {
       return undefined;
     }
 
-    let typeReference = getTypeReferenceAsString(type, typeChecker);
-    if (!typeReference) {
+    const _typeReference = getTypeReferenceAsString(type, typeChecker);
+
+    if (!_typeReference) {
       return undefined;
     }
-    typeReference = replaceImportPath(typeReference, hostFilename);
-    if (typeReference && typeReference.includes('require')) {
+
+    const { typeReference, importPath } = replaceImportPath(
+      _typeReference,
+      hostFilename,
+    );
+
+    if (importPath) {
       // add top-level import to eagarly load class metadata
-      const importPath = /\(\"([^)]).+(\")/.exec(typeReference)[0];
-      if (importPath) {
-        let importsToAdd = importsToAddPerFile.get(hostFilename);
-        if (!importsToAdd) {
-          importsToAdd = new Set();
-          importsToAddPerFile.set(hostFilename, importsToAdd);
-        }
-        importsToAdd.add(importPath.slice(2, importPath.length - 1));
-      }
+      this.importsToAdd.add(importPath);
     }
 
     return f.createIdentifier(typeReference);
   }
 
-  private createEagerImports(
-    f: ts.NodeFactory,
-    fileName: string,
-  ): ts.ImportEqualsDeclaration[] {
-    const importsToAdd = importsToAddPerFile.get(fileName);
-
-    if (!importsToAdd) {
+  private createEagerImports(f: ts.NodeFactory): ts.ImportEqualsDeclaration[] {
+    if (!this.importsToAdd.size) {
       return [];
     }
 
-    return Array.from(importsToAdd).map((path, index) => {
+    return Array.from(this.importsToAdd).map((path, index) => {
       return createImportEquals(f, 'eager_import_' + index, path);
     });
   }

tests/plugin/fixtures/create-cat-alt.dto.ts

@@ -66,7 +66,7 @@ let CreateCatDto2 = class CreateCatDto2 {
         this.status = Status.ENABLED;
     }
     static _GRAPHQL_METADATA_FACTORY() {
-        return { name: { type: () => String, description: "name description" }, age: { type: () => Number, description: "test on age" }, tags: { type: () => [String] }, status: { type: () => Status }, breed: { nullable: true, type: () => String }, nodes: { type: () => [Object] }, alias: { type: () => Object }, numberAlias: { type: () => Number }, union: { type: () => Object }, intersection: { type: () => Object }, optionalBoolean: { nullable: true, type: () => Boolean }, nested: { type: () => ({ first: { type: () => String }, second: { type: () => Number }, status: { type: () => Status }, tags: { type: () => [String] }, nodes: { type: () => [Object] }, alias: { type: () => Object }, numberAlias: { type: () => Number } }) }, tuple: { type: () => Object } };
+        return { name: { type: () => String, description: "name description" }, age: { type: () => Number, description: "test on age" }, tags: { type: () => [String] }, status: { type: () => Status }, breed: { nullable: true, type: () => String }, nodes: { type: () => [Object] }, alias: { type: () => Object }, numberAlias: { type: () => Number }, union: { type: () => Object }, intersection: { type: () => Object }, optionalBoolean: { nullable: true, type: () => Boolean }, nested: { type: () => Object }, prop: { type: () => Object }, tuple: { type: () => Object } };
     }
 };
 CreateCatDto2 = __decorate([

tests/plugin/plugin-utils.spec.ts

@@ -0,0 +1,53 @@
+import { replaceImportPath } from '../../lib/plugin/utils/plugin-utils';
+
+describe('plugin-utils', () => {
+  describe('replaceImportPath', () => {
+    it('should replace path to relative', () => {
+      const actual = replaceImportPath(
+        'import("/root/project/src/author.model").Author',
+        '/root/project/src/post.model.ts',
+      );
+
+      expect(actual).toStrictEqual({
+        typeReference: 'require("./author.model").Author',
+        importPath: './author.model',
+      });
+    });
+
+    it('should shorten path if it points to node_modules', () => {
+      const actual = replaceImportPath(
+        'import("/root/project/src/node_modules/dependency/author.model").Author',
+        '/root/project/src/post.model.ts',
+      );
+
+      expect(actual).toStrictEqual({
+        typeReference: 'require("dependency/author.model").Author',
+        importPath: 'dependency/author.model',
+      });
+    });
+
+    it('should shorten path if it points to node_modules/@types', () => {
+      const actual = replaceImportPath(
+        'import("/root/project/src/node_modules/@types/dependency/author.model").Author',
+        '/root/project/src/post.model.ts',
+      );
+
+      expect(actual).toStrictEqual({
+        typeReference: 'require("dependency/author.model").Author',
+        importPath: 'dependency/author.model',
+      });
+    });
+
+    it('should shorten path if it points to dependency index file', () => {
+      const actual = replaceImportPath(
+        'import("/root/project/src/node_modules/dependency/index").Author',
+        '/root/project/src/post.model.ts',
+      );
+
+      expect(actual).toStrictEqual({
+        typeReference: 'require("dependency").Author',
+        importPath: 'dependency',
+      });
+    });
+  });
+});