Avoid importing concrete values when only types are needed

Author: captbaritone

examples/apollo-server/schema.ts

@@ -6,8 +6,8 @@
 import UserClass from "./models/User";
 import queryAllUsersResolver from "./models/User";
 import queryMeResolver from "./models/User";
-import { person as queryPersonResolver } from "./Query";
 import { GraphQLSchema, GraphQLObjectType, GraphQLNonNull, GraphQLList, GraphQLString, GraphQLInterfaceType } from "graphql";
+import { person as queryPersonResolver } from "./Query";
 export function getSchema(): GraphQLSchema {
     const GroupType: GraphQLObjectType = new GraphQLObjectType({
         name: "Group",

examples/express-graphql-http/schema.ts

@@ -6,8 +6,8 @@
 import UserClass from "./models/User";
 import queryAllUsersResolver from "./models/User";
 import queryMeResolver from "./models/User";
-import { person as queryPersonResolver } from "./interfaces/IPerson";
 import { GraphQLSchema, GraphQLObjectType, GraphQLNonNull, GraphQLList, GraphQLString, GraphQLInterfaceType } from "graphql";
+import { person as queryPersonResolver } from "./interfaces/IPerson";
 export function getSchema(): GraphQLSchema {
     const GroupType: GraphQLObjectType = new GraphQLObjectType({
         name: "Group",

examples/incremental-migration/schemas/gratsGeneratedSchema.ts

@@ -1,7 +1,7 @@
 // DO NOT USE DIRECTLY. Prefer the merged schema in `./mergedSchema.ts`.
 
-import { user as queryUserResolver } from "./../models";
 import { GraphQLSchema, GraphQLObjectType, GraphQLNonNull, GraphQLString, GraphQLID } from "graphql";
+import { user as queryUserResolver } from "./../models";
 export function getSchema(): GraphQLSchema {
     const UserType: GraphQLObjectType = new GraphQLObjectType({
         name: "User",

examples/next-js/schema.ts

@@ -5,8 +5,8 @@
 
 import UserClass from "./app/api/graphql/models/User";
 import queryAllUsersResolver from "./app/api/graphql/models/User";
-import { me as queryMeResolver, person as queryPersonResolver } from "./app/api/graphql/Query";
 import { GraphQLSchema, GraphQLObjectType, GraphQLNonNull, GraphQLList, GraphQLString, GraphQLInterfaceType } from "graphql";
+import { me as queryMeResolver, person as queryPersonResolver } from "./app/api/graphql/Query";
 export function getSchema(): GraphQLSchema {
     const GroupType: GraphQLObjectType = new GraphQLObjectType({
         name: "Group",

examples/production-app/schema.ts

@@ -3,8 +3,9 @@
  * Do not manually edit. Regenerate by running `npx grats`.
  */
 
-import { GqlScalar } from "grats";
-import { GqlDate as DateInternal } from "./graphql/CustomScalars";
+import type { GqlScalar } from "grats";
+import type { GqlDate as DateInternal } from "./graphql/CustomScalars";
+import { GraphQLSchema, GraphQLDirective, DirectiveLocation, GraphQLNonNull, GraphQLInt, specifiedDirectives, GraphQLObjectType, GraphQLList, GraphQLString, GraphQLScalarType, GraphQLID, GraphQLInterfaceType, GraphQLBoolean, GraphQLInputObjectType } from "graphql";
 import { id as likeIdResolver, id as userIdResolver, id as postIdResolver, node as queryNodeResolver, nodes as queryNodesResolver } from "./graphql/Node";
 import { nodes as postConnectionNodesResolver, posts as queryPostsResolver } from "./models/PostConnection";
 import { nodes as likeConnectionNodesResolver, likes as queryLikesResolver, postLikes as subscriptionPostLikesResolver } from "./models/LikeConnection";
@@ -14,7 +15,6 @@ import { Viewer as queryViewerResolver } from "./models/Viewer";
 import { createLike as mutationCreateLikeResolver } from "./models/Like";
 import { createPost as mutationCreatePostResolver } from "./models/Post";
 import { createUser as mutationCreateUserResolver } from "./models/User";
-import { GraphQLSchema, GraphQLDirective, DirectiveLocation, GraphQLNonNull, GraphQLInt, specifiedDirectives, GraphQLObjectType, GraphQLList, GraphQLString, GraphQLScalarType, GraphQLID, GraphQLInterfaceType, GraphQLBoolean, GraphQLInputObjectType } from "graphql";
 export type SchemaConfig = {
     scalars: {
         Date: GqlScalar<DateInternal>;

examples/strict-semantic-nullability/schema.ts

@@ -6,7 +6,7 @@
 import UserClass from "./models/User";
 import queryAllUsersResolver from "./models/User";
 import queryMeResolver from "./models/User";
-import { defaultFieldResolver, GraphQLSchema, GraphQLDirective, DirectiveLocation, GraphQLList, GraphQLInt, specifiedDirectives, GraphQLObjectType, GraphQLNonNull, GraphQLString, GraphQLInterfaceType } from "graphql";
+import { GraphQLSchema, GraphQLDirective, DirectiveLocation, GraphQLList, GraphQLInt, specifiedDirectives, GraphQLObjectType, GraphQLNonNull, GraphQLString, defaultFieldResolver, GraphQLInterfaceType } from "graphql";
 import { person as queryPersonResolver } from "./interfaces/IPerson";
 import { countdown as subscriptionCountdownResolver, nullItems as subscriptionNullItemsResolver, nullIterable as subscriptionNullIterableResolver } from "./Subscription";
 async function assertNonNull<T>(value: T | Promise<T>): Promise<T> {

examples/yoga/schema.ts

@@ -6,9 +6,9 @@
 import UserClass from "./models/User";
 import queryAllUsersResolver from "./models/User";
 import queryMeResolver from "./models/User";
+import { GraphQLSchema, GraphQLObjectType, GraphQLNonNull, GraphQLList, GraphQLString, GraphQLInterfaceType, GraphQLInt } from "graphql";
 import { person as queryPersonResolver } from "./interfaces/IPerson";
 import { countdown as subscriptionCountdownResolver } from "./Subscription";
-import { GraphQLSchema, GraphQLObjectType, GraphQLNonNull, GraphQLList, GraphQLString, GraphQLInterfaceType, GraphQLInt } from "graphql";
 export function getSchema(): GraphQLSchema {
     const GroupType: GraphQLObjectType = new GraphQLObjectType({
         name: "Group",

src/codegen/TSAstBuilder.ts

@@ -15,13 +15,19 @@ export type JsonValue =
 
 const F = ts.factory;
 
+export type ImportSpecifier = {
+  name: string;
+  as?: string;
+  isTypeOnly: boolean;
+};
+
 /**
  * A helper class to build up a TypeScript document AST.
  */
 export default class TSAstBuilder {
   _globalNames: Map<string, number> = new Map();
   _imports: ts.Statement[] = [];
-  imports: Map<string, { name: string; as?: string }[]> = new Map();
+  imports: Map<string, ImportSpecifier[]> = new Map();
   _helpers: ts.Statement[] = [];
   _statements: ts.Statement[] = [];
 
@@ -170,21 +176,26 @@ export default class TSAstBuilder {
     );
   }
 
-  import(from: string, names: { name: string; as?: string }[]) {
+  import(from: string, names: ImportSpecifier[]) {
     let moduleImports = this.imports.get(from);
     if (moduleImports == null) {
       moduleImports = [];
       this.imports.set(from, moduleImports);
     }
-    for (const { name, as } of names) {
+    for (const { name, as, isTypeOnly } of names) {
       let seen = false;
       for (const imp of moduleImports) {
         if (imp.name === name && imp.as === as) {
+          // If a name is imported both as type only and as a value, it needs to
+          // be imported as a value.
+          if (imp.isTypeOnly && !isTypeOnly) {
+            imp.isTypeOnly = false;
+          }
           seen = true;
         }
       }
       if (!seen) {
-        moduleImports.push({ name, as });
+        moduleImports.push({ name, as, isTypeOnly });
       }
     }
   }
@@ -203,6 +214,7 @@ export default class TSAstBuilder {
     tsModulePath: string,
     exportName: string | null,
     localName: string,
+    isTypeOnly: boolean,
   ): void {
     const abs = resolveRelativePath(tsModulePath);
     const relative = replaceExt(
@@ -213,7 +225,9 @@ export default class TSAstBuilder {
     if (exportName == null) {
       this.importDefault(modulePath, localName);
     } else {
-      this.import(modulePath, [{ name: exportName, as: localName }]);
+      this.import(modulePath, [
+        { name: exportName, as: localName, isTypeOnly },
+      ]);
     }
   }
 
@@ -228,16 +242,21 @@ export default class TSAstBuilder {
     );
 
     for (const [from, names] of this.imports) {
+      const allImportsAreTypeOnly = names.every((name) => name.isTypeOnly);
       const namedImports = names.map((name) => {
+        // If all the imports are type only, then we don't need to mark each
+        // individual import as type only.
+        const isTypeOnly = !allImportsAreTypeOnly && name.isTypeOnly;
+
         if (name.as && name.as !== name.name) {
           return F.createImportSpecifier(
-            false,
+            isTypeOnly,
             F.createIdentifier(name.name),
             F.createIdentifier(name.as),
           );
         } else {
           return F.createImportSpecifier(
-            false,
+            isTypeOnly,
             undefined,
             F.createIdentifier(name.name),
           );
@@ -247,7 +266,7 @@ export default class TSAstBuilder {
         F.createImportDeclaration(
           undefined,
           F.createImportClause(
-            false,
+            allImportsAreTypeOnly,
             undefined,
             F.createNamedImports(namedImports),
           ),

src/codegen/resolverCodegen.ts

@@ -79,6 +79,7 @@ export default class ResolverCodegen {
           resolver.path,
           resolver.exportName,
           resolverName,
+          false,
         );
         return this.ts.method(
           methodName,
@@ -109,6 +110,7 @@ export default class ResolverCodegen {
           resolver.path,
           resolver.exportName,
           resolverName,
+          false,
         );
         return this.ts.method(
           methodName,
@@ -184,7 +186,7 @@ export default class ResolverCodegen {
         );
       case "derivedContext": {
         const localName = this.getDerivedContextName(arg.path, arg.exportName);
-        this.ts.importUserConstruct(arg.path, arg.exportName, localName);
+        this.ts.importUserConstruct(arg.path, arg.exportName, localName, false);
         return F.createCallExpression(
           F.createIdentifier(localName),
           undefined,
@@ -257,7 +259,9 @@ export default class ResolverCodegen {
   }
 
   defaultResolverMethod(methodName: string): ts.MethodDeclaration {
-    this.ts.import("graphql", [{ name: "defaultFieldResolver" }]);
+    this.ts.import("graphql", [
+      { name: "defaultFieldResolver", isTypeOnly: false },
+    ]);
     return this.ts.method(
       methodName,
       RESOLVER_ARGS.map((name) => this.ts.param(name)),

src/codegen/resolverMapCodegen.ts

@@ -49,7 +49,9 @@ class Codegen {
     // coupled to just TypeScript and GraphQL JS. Ideally we would not do
     // _anything_ coupled to other libraries but instead provide a way for users
     // to do this themselves.
-    this.ts.import("@graphql-tools/utils", [{ name: "IResolvers" }]);
+    this.ts.import("@graphql-tools/utils", [
+      { name: "IResolvers", isTypeOnly: true },
+    ]);
     this.ts.functionDeclaration(
       "getResolverMap",
       [F.createModifier(ts.SyntaxKind.ExportKeyword)],