graphql-jerky 1.0.5 → 1.0.7

package/build/lib.cjs

@@ -1,12 +1,12 @@
 'use strict';
 
+var path = require('path');
+var url = require('url');
 var graphql = require('graphql');
 var jen = require('jennifer-js');
 var format = require('jennifer-js/format');
 var partition = require('just-partition');
 var pascalCase = require('just-pascal-case');
-var path = require('path');
-var url = require('url');
 var fs = require('fs/promises');
 var ts = require('typescript');
 var glob = require('glob');
@@ -28,29 +28,44 @@ function resolveModule(specifier, referrer) {
     if (url.protocol === "file:") {
         return parseSource(url);
     }
-    else {
-        throw new Error(`Unsupported protocol: ${url.protocol}`);
+    throw new Error(`Unsupported protocol: ${url.protocol}`);
+}
+function pushExports(e, name, ...decls) {
+    if (!e[name]) {
+        e[name] = [];
     }
+    e[name].push(...decls);
 }
 async function findExports(source, resolveModuleFn = resolveModule) {
     const exports = {};
     const namedExports = [];
     for (const node of source.statements) {
-        if (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node)) {
+        if (ts.isFunctionDeclaration(node) ||
+            ts.isClassDeclaration(node) ||
+            ts.isInterfaceDeclaration(node)) {
             if (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
-                if (node.modifiers.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword)) {
-                    (exports.default || (exports.default = [])).push({ declaration: node, source, name: "default" });
-                }
-                else if (node.name) {
-                    const name = node.name.getText(source);
-                    (exports[name] || (exports[name] = [])).push({ declaration: node, source, name: name });
+                const name = node.modifiers.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword)
+                    ? "default"
+                    : node.name?.getText(source);
+                if (name) {
+                    pushExports(exports, name, {
+                        declaration: node,
+                        source,
+                        name: name,
+                    });
                 }
             }
         }
-        else if (ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isModuleDeclaration(node)) {
+        else if (ts.isTypeAliasDeclaration(node) ||
+            ts.isEnumDeclaration(node) ||
+            ts.isModuleDeclaration(node)) {
             if (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
                 const name = node.name.getText(source);
-                (exports[name] || (exports[name] = [])).push({ declaration: node, source, name: name });
+                pushExports(exports, name, {
+                    declaration: node,
+                    source,
+                    name: name,
+                });
             }
         }
         else if (ts.isVariableStatement(node)) {
@@ -58,7 +73,11 @@ async function findExports(source, resolveModuleFn = resolveModule) {
                 for (const decl of node.declarationList.declarations) {
                     if (decl.name) {
                         const name = decl.name.getText(source);
-                        (exports[name] || (exports[name] = [])).push({ declaration: decl, source, name: name });
+                        pushExports(exports, name, {
+                            declaration: decl,
+                            source,
+                            name: name,
+                        });
                     }
                 }
             }
@@ -76,7 +95,7 @@ async function findExports(source, resolveModuleFn = resolveModule) {
                         if (!(name in moduleExports)) {
                             throw new Error(`Exported name ${name} not found in ${JSON.stringify(specifier)}`);
                         }
-                        (exports[name] || (exports[name] = [])).push(...moduleExports[name]);
+                        pushExports(exports, name, ...moduleExports[name]);
                     }
                 }
                 else {
@@ -88,7 +107,9 @@ async function findExports(source, resolveModuleFn = resolveModule) {
                     }
                 }
             }
-            else if (!node.exportClause && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+            else if (!node.exportClause &&
+                node.moduleSpecifier &&
+                ts.isStringLiteral(node.moduleSpecifier)) {
                 // export * from 'whatever';
                 Object.assign(exports, await findExports(await resolveModuleFn(node.moduleSpecifier.text, new URL(source.fileName)), resolveModuleFn));
             }
@@ -99,9 +120,10 @@ async function findExports(source, resolveModuleFn = resolveModule) {
         for (const statement of source.statements) {
             if (ts.isVariableStatement(statement)) {
                 for (const decl of statement.declarationList.declarations) {
-                    if (ts.isIdentifier(decl.name) && decl.name.getText(source) in names) {
+                    if (ts.isIdentifier(decl.name) &&
+                        decl.name.getText(source) in names) {
                         const name = names[decl.name.getText(source)];
-                        (exports[name] || (exports[name] = [])).push({
+                        pushExports(exports, name, {
                             declaration: decl,
                             source,
                             name: names[decl.name.getText(source)],
@@ -110,9 +132,11 @@ async function findExports(source, resolveModuleFn = resolveModule) {
                 }
             }
             if (ts.isFunctionDeclaration(statement)) {
-                if (statement.name && ts.isIdentifier(statement.name) && statement.name.getText(source) in names) {
+                if (statement.name &&
+                    ts.isIdentifier(statement.name) &&
+                    statement.name.getText(source) in names) {
                     const name = names[statement.name.getText(source)];
-                    (exports[name] || (exports[name] = [])).push({
+                    pushExports(exports, name, {
                         declaration: statement,
                         source,
                         name: names[statement.name.getText(source)],
@@ -120,9 +144,11 @@ async function findExports(source, resolveModuleFn = resolveModule) {
                 }
             }
             if (ts.isClassDeclaration(statement)) {
-                if (statement.name && ts.isIdentifier(statement.name) && statement.name.getText(source) in names) {
+                if (statement.name &&
+                    ts.isIdentifier(statement.name) &&
+                    statement.name.getText(source) in names) {
                     const name = names[statement.name.getText(source)];
-                    (exports[name] || (exports[name] = [])).push({
+                    pushExports(exports, name, {
                         declaration: statement,
                         source,
                         name: names[statement.name.getText(source)],
@@ -130,9 +156,11 @@ async function findExports(source, resolveModuleFn = resolveModule) {
                 }
             }
             if (ts.isTypeAliasDeclaration(statement)) {
-                if (statement.name && ts.isIdentifier(statement.name) && statement.name.getText(source) in names) {
+                if (statement.name &&
+                    ts.isIdentifier(statement.name) &&
+                    statement.name.getText(source) in names) {
                     const name = names[statement.name.getText(source)];
-                    (exports[name] || (exports[name] = [])).push({
+                    pushExports(exports, name, {
                         declaration: statement,
                         source,
                         name: names[statement.name.getText(source)],
@@ -140,9 +168,11 @@ async function findExports(source, resolveModuleFn = resolveModule) {
                 }
             }
             if (ts.isInterfaceDeclaration(statement)) {
-                if (statement.name && ts.isIdentifier(statement.name) && statement.name.getText(source) in names) {
+                if (statement.name &&
+                    ts.isIdentifier(statement.name) &&
+                    statement.name.getText(source) in names) {
                     const name = names[statement.name.getText(source)];
-                    (exports[name] || (exports[name] = [])).push({
+                    pushExports(exports, name, {
                         declaration: statement,
                         source,
                         name: names[statement.name.getText(source)],
@@ -150,9 +180,11 @@ async function findExports(source, resolveModuleFn = resolveModule) {
                 }
             }
             if (ts.isEnumDeclaration(statement)) {
-                if (statement.name && ts.isIdentifier(statement.name) && statement.name.getText(source) in names) {
+                if (statement.name &&
+                    ts.isIdentifier(statement.name) &&
+                    statement.name.getText(source) in names) {
                     const name = names[statement.name.getText(source)];
-                    (exports[name] || (exports[name] = [])).push({
+                    pushExports(exports, name, {
                         declaration: statement,
                         source,
                         name: names[statement.name.getText(source)],
@@ -160,13 +192,15 @@ async function findExports(source, resolveModuleFn = resolveModule) {
                 }
             }
             if (ts.isImportDeclaration(statement)) {
-                if (statement.importClause && statement.importClause.namedBindings &&
+                if (statement.importClause?.namedBindings &&
                     ts.isNamedImports(statement.importClause.namedBindings)) {
                     let importExports;
                     for (const element of statement.importClause.namedBindings.elements) {
-                        if (element.propertyName && ts.isIdentifier(element.propertyName) &&
+                        if (element.propertyName &&
+                            ts.isIdentifier(element.propertyName) &&
                             element.propertyName.getText(source) in names) {
-                            if (!importExports && ts.isStringLiteral(statement.moduleSpecifier)) {
+                            if (!importExports &&
+                                ts.isStringLiteral(statement.moduleSpecifier)) {
                                 const specifier = statement.moduleSpecifier.getText(source);
                                 importExports = await findExports(await resolveModuleFn(specifier, new URL(source.fileName)), resolveModuleFn);
                             }
@@ -177,7 +211,7 @@ async function findExports(source, resolveModuleFn = resolveModule) {
                                 throw new Error(`Exported name ${element.name.getText(source)} not found in ${JSON.stringify(statement.moduleSpecifier.getText(source))}`);
                             }
                             const name = names[element.propertyName.getText(source)];
-                            (exports[name] || (exports[name] = [])).push({
+                            pushExports(exports, name, {
                                 declaration: element,
                                 source,
                                 name: names[element.propertyName.getText(source)],
@@ -190,9 +224,11 @@ async function findExports(source, resolveModuleFn = resolveModule) {
     }
     return exports;
 }
-async function parseModule(source) {
-    const url$1 = typeof source === 'string' ? url.pathToFileURL(path.resolve(source)) : new URL(source.fileName);
-    source = typeof source === 'string' ? await parseSource(url$1) : source;
+async function parseModule(sourceOrPath) {
+    const url$1 = typeof sourceOrPath === "string"
+        ? url.pathToFileURL(path.resolve(sourceOrPath))
+        : new URL(sourceOrPath.fileName);
+    const source = typeof sourceOrPath === "string" ? await parseSource(url$1) : sourceOrPath;
     return {
         path: url$1,
         exports: await findExports(source),
@@ -204,7 +240,8 @@ async function parseModule(source) {
  *
  * @see https://github.com/microsoft/TypeScript/blob/0d0a79371471d627ae298a145f8009b05cbccb72/src/compiler/scanner.ts#L81
  */
-const keywords = new Set(Object.keys(ts.textToKeywordObj));
+const keywords = new Set(Object.keys(ts
+    .textToKeywordObj));
 
 class RequiredPackages {
     requires;
@@ -224,8 +261,11 @@ class RequiredPackages {
             this.requires[pkg] = new Set();
         }
         let symbol = alias || name;
-        if ((symbol in this.symbols || keywords.has(symbol)) && this.symbols[symbol] !== pkg) {
-            for (let i = 1; this.symbols[symbol = name + "$" + i] && this.symbols[symbol] !== pkg; i++)
+        if ((symbol in this.symbols || keywords.has(symbol)) &&
+            this.symbols[symbol] !== pkg) {
+            for (let i = 1; 
+            // biome-ignore lint/suspicious/noAssignInExpressions: it works don't fix it
+            this.symbols[(symbol = `${name}$${i}`)] && this.symbols[symbol] !== pkg; i++)
                 ;
         }
         this.requires[pkg].add(symbol);
@@ -238,7 +278,9 @@ class RequiredPackages {
 }
 
 function renderSymbolReference(pkgs, ref, alias) {
-    const ns = (ref.module ? jen.jen.id(pkgs.addRequires(ref.module, ref.symbol, alias ?? ref.alias)) : jen.jen.id(ref.symbol));
+    const ns = ref.module
+        ? jen.jen.id(pkgs.addRequires(ref.module, ref.symbol, alias ?? ref.alias))
+        : jen.jen.id(ref.symbol);
     return ref.property ? ns.dot(ref.property) : ns;
 }
 
@@ -265,7 +307,7 @@ function renderImports(base, imports, aliases, extMode = "omit") {
         if (mod.startsWith("file:///")) {
             mod = url.fileURLToPath(mod);
         }
-        if (mod.startsWith('/')) {
+        if (mod.startsWith("/")) {
             mod = path.relative(base, mod);
             if (!mod.startsWith(".")) {
                 mod = `./${mod}`;
@@ -280,13 +322,21 @@ function renderImports(base, imports, aliases, extMode = "omit") {
         else if (extMode === "replace") {
             mod = mod.replace(/\.ts$/, ".js");
         }
-        return jen.import.obj(...Array.from(symbols)
-            .sort((a, b) => a.localeCompare(b) || importAlias(a).localeCompare(importAlias(b)))
-            .map((symbol) => symbol in aliases ? jen.id(aliases[symbol]).as.id(symbol) : jen.id(symbol))).from.lit(mod);
+        return jen.import
+            .obj(...Array.from(symbols)
+            .sort((a, b) => a.localeCompare(b) ||
+            importAlias(a).localeCompare(importAlias(b)))
+            .map((symbol) => symbol in aliases
+            ? jen.id(aliases[symbol]).as.id(symbol)
+            : jen.id(symbol)))
+            .from.lit(mod);
     }));
 }
 function renderAstNode(astNode) {
-    return jen.id("JSON").dot("parse").call(jen.literal(JSON.stringify(astNode, (key, value) => key === "loc" ? undefined : value)));
+    return jen
+        .id("JSON")
+        .dot("parse")
+        .call(jen.literal(JSON.stringify(astNode, (key, value) => key === "loc" ? undefined : value)));
 }
 function isBuiltInDirective(name) {
     // https://spec.graphql.org/draft/#sec-Type-System.Directives.Built-in-Directives
@@ -311,6 +361,7 @@ class GeneratorContext {
     _resolversInfo;
     _subscribersInfo;
     _graphqlModuleSpecifier;
+    _includeSubscriptionFieldResolvers;
     constructor(options = {}) {
         this._scalarsInfo = options.scalarsInfo ?? {};
         this._fieldDirectivesInfo = options.fieldDirectivesInfo ?? {};
@@ -320,32 +371,46 @@ class GeneratorContext {
         this._graphqlModuleSpecifier = options.graphqlModuleSpecifier ?? "graphql";
         this._pkgs = new RequiredPackages();
         this._extMode = options.extMode ?? "omit";
+        this._includeSubscriptionFieldResolvers = options.includeSubscriptionFieldResolvers ?? false;
     }
     _gql(name) {
         return jen.id(this._pkgs.addRequires(this._graphqlModuleSpecifier, name));
     }
     _renderGraphQLTypeIdentifier(type) {
         if (type instanceof graphql.GraphQLNonNull) {
-            return jen.new.add(this._gql("GraphQLNonNull")).params(this._renderGraphQLTypeIdentifier(type.ofType));
+            return jen.new
+                .add(this._gql("GraphQLNonNull"))
+                .params(this._renderGraphQLTypeIdentifier(type.ofType));
         }
         if (type instanceof graphql.GraphQLList) {
-            return jen.new.add(this._gql("GraphQLList")).params(this._renderGraphQLTypeIdentifier(type.ofType));
+            return jen.new
+                .add(this._gql("GraphQLList"))
+                .params(this._renderGraphQLTypeIdentifier(type.ofType));
         }
         if (type instanceof graphql.GraphQLScalarType) {
             if (isPrimitiveType(type)) {
-                return this._gql("GraphQL" + type.name);
+                return this._gql(`GraphQL${type.name}`);
             }
-            return jen.id(type.name + "Scalar");
+            return jen.id(`${type.name}Scalar`);
         }
-        return jen.id(type.name + (type instanceof graphql.GraphQLEnumType ? "Enum" : type instanceof graphql.GraphQLDirective ? "Directive" : "Type"));
+        return jen.id(type.name +
+            (type instanceof graphql.GraphQLEnumType
+                ? "Enum"
+                : type instanceof graphql.GraphQLDirective
+                    ? "Directive"
+                    : "Type"));
     }
     _renderArgumentsObject(args) {
         return jen.obj(...Array.from(args)
             .sort(compareName)
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
             .map((arg) => jen.prop(arg.name, jen.obj(jen.prop("type", this._renderGraphQLTypeIdentifier(arg.type)), ...truthify([
-            arg.description && jen.prop("description", jen.lit(arg.description)),
-            arg.defaultValue && jen.prop("defaultValue", jen.lit(arg.defaultValue)),
-            arg.deprecationReason && jen.prop("deprecationReason", jen.lit(arg.deprecationReason)),
+            arg.description &&
+                jen.prop("description", jen.lit(arg.description)),
+            arg.defaultValue &&
+                jen.prop("defaultValue", jen.lit(arg.defaultValue)),
+            arg.deprecationReason &&
+                jen.prop("deprecationReason", jen.lit(arg.deprecationReason)),
         ])))));
     }
     _renderValueNode(node) {
@@ -376,7 +441,8 @@ class GeneratorContext {
             if (type instanceof graphql.GraphQLObjectType && !resolver) {
                 // try to find resolver in interface in the declaration order
                 for (const iface of type.getInterfaces()) {
-                    if ((resolver = this._resolversInfo[iface.name]?.[f.name])) {
+                    resolver = this._resolversInfo[iface.name]?.[f.name];
+                    if (resolver) {
                         break;
                     }
                 }
@@ -390,24 +456,36 @@ class GeneratorContext {
                         continue;
                     }
                     if (!resolveFn) {
-                        resolveFn = jen.arrow(jen.id("source").op(":").any).id("source").dot(f.name);
+                        resolveFn = jen
+                            .arrow(jen.id("source").op(":").any)
+                            .id("source")
+                            .dot(f.name);
                     }
-                    resolveFn = renderSymbolReference(this._pkgs, ref, `apply${pascalCase(directive.name.value)}FieldDirective`).call(resolveFn, ...(directive.arguments?.length ? [this._renderArgumentNodes(directive.arguments)] : []));
+                    resolveFn = renderSymbolReference(this._pkgs, ref, `apply${pascalCase(directive.name.value)}FieldDirective`).call(resolveFn, ...(directive.arguments?.length
+                        ? [this._renderArgumentNodes(directive.arguments)]
+                        : []));
                 }
             }
             if (resolveFn) {
                 // args probably don't need to be transformed if there's no resolver
                 const argsWithDirectives = truthify(f.args?.map((arg) => this._findInputDirectiveInfoFromArgOrField(arg, inputFieldDirectives)) ?? []);
                 if (argsWithDirectives.length) {
-                    resolveFn = jen.parens(jen.params(jen.prop("next", this._gql("GraphQLFieldResolver").types(jen.any, jen.any))).op(":")
+                    resolveFn = jen
+                        .parens(jen
+                        .params(jen.prop("next", this._gql("GraphQLFieldResolver").types(jen.any, jen.any)))
+                        .op(":")
                         .add(this._gql("GraphQLFieldResolver"))
-                        .types(jen.any, jen.any, jen.id(type.name).dot(pascalCase(f.name + "_args")))
-                        .op("=>").arrow(jen.id("source"), jen.id("args"), jen.id("context"), jen.id("info")).id("next").call(jen.id("source"), this._renderInputFieldsWithDirectives(jen.id("args"), argsWithDirectives, argsWithDirectives.length < f.args.length), jen.id("context"), jen.id("info"))).call(resolveFn);
+                        .types(jen.any, jen.any, jen.id(type.name).dot(pascalCase(`${f.name}_args`)))
+                        .op("=>")
+                        .arrow(jen.id("source"), jen.id("args"), jen.id("context"), jen.id("info"))
+                        .id("next")
+                        .call(jen.id("source"), this._renderInputFieldsWithDirectives(jen.id("args"), argsWithDirectives, argsWithDirectives.length < (f.args?.length ?? 0)), jen.id("context"), jen.id("info")))
+                        .call(resolveFn);
                 }
             }
         }
         // NOTE: The way subscribers work in the graphql-js is by calling `subscribe` on the top level fields, and then
-        //       calling `resolve` on the nested fields. This means that subscribers only need to be defined on 
+        //       calling `resolve` on the nested fields. This means that subscribers only need to be defined on
         //       `Subscription`.
         //
         //       In theory, an alternate implementation could be created to call `subscribe` at every level, but considering
@@ -421,18 +499,25 @@ class GeneratorContext {
             f.args?.length && jen.prop("args", this._renderArgumentsObject(f.args)),
             f.defaultValue && jen.prop("defaultValue", jen.lit(f.defaultValue)),
             f.description && jen.prop("description", jen.lit(f.description)),
-            f.deprecationReason && jen.prop("deprecationReason", jen.lit(f.deprecationReason)),
+            f.deprecationReason &&
+                jen.prop("deprecationReason", jen.lit(f.deprecationReason)),
             // NOTE: Resolver functions on interface definitions are not used by the default graphql-js
             //       executor implementation, but nonetheless accessible by a potential alternate implementation.
             resolveFn && jen.prop("resolve", jen.parens(resolveFn).as.any),
-            subscriber && jen.prop("subscribe", jen.parens(renderSymbolReference(this._pkgs, subscriber)).as.any),
+            subscriber &&
+                jen.prop("subscribe", jen.parens(renderSymbolReference(this._pkgs, subscriber)).as.any),
             astNodeExpr && jen.prop("astNode", astNodeExpr),
         ]));
     }
     _renderFieldsThunk(type, inputFieldDirectives, includeAstNodes, noresolver) {
         let astNodeExpr;
         if (includeAstNodes) {
-            astNodeExpr = jen.id(type.name + "Type").dot("astNode").op("?").dot("fields").op("?.");
+            astNodeExpr = jen
+                .id(`${type.name}Type`)
+                .dot("astNode")
+                .op("?")
+                .dot("fields")
+                .op("?.");
         }
         return jen.arrow().parens(jen.obj(...Object.values(type.getFields())
             .map((field, i) => [field, i])
@@ -454,7 +539,7 @@ class GeneratorContext {
             return "unknown";
         }
         if (type instanceof graphql.GraphQLEnumType) {
-            return "E" + type.name;
+            return `E${type.name}`;
         }
         return type.name;
     }
@@ -490,19 +575,22 @@ class GeneratorContext {
             }
         }
         if (!returnType) {
-            console.log("WARNING: Could not determine scalar " + type.name + " type from parseValue or parseLiteral");
+            console.log(`WARNING: Could not determine scalar ${type.name} type from parseValue or parseLiteral`);
         }
-        return (this._scalarTypeTypeCache[type.name] = returnType);
+        this._scalarTypeTypeCache[type.name] = returnType;
+        return returnType;
     }
     _renderGraphQLTypeType(type) {
         if (type instanceof graphql.GraphQLNonNull) {
             return this._renderGraphQLTypeType(type.ofType);
         }
         if (type instanceof graphql.GraphQLList) {
-            return jen.id("Array").types(this._renderOptionalGraphQLTypeType(type.ofType));
+            return jen
+                .id("Array")
+                .types(this._renderOptionalGraphQLTypeType(type.ofType));
         }
         if (type instanceof graphql.GraphQLDirective) {
-            throw new Error("unexpected directive type " + type.name);
+            throw new Error(`unexpected directive type ${type.name}`);
         }
         return jen.id(this._deriveGraphQLTypeName(type));
     }
@@ -513,13 +601,20 @@ class GeneratorContext {
     }
     _renderGraphQLObjectTypeDefinition(type, { inputFieldDirectives, includeAstNodes }) {
         const typeInterfaces = type.getInterfaces();
-        return jen.new.add(this._gql("GraphQLObjectType")).call(jen.obj(jen.prop("name", jen.lit(type.name)), jen.prop("fields", this._renderFieldsThunk(type, inputFieldDirectives, includeAstNodes, type.name === "Subscription")), ...truthify([
-            type.description && jen.prop("description", jen.lit(type.description)),
-            typeInterfaces.length && jen.prop("interfaces", jen.arrow().arr(
-            // do not sort interfaces, the declaration order may be important
-            ...typeInterfaces.map(this._renderGraphQLTypeIdentifier, this))),
-            includeAstNodes && type.astNode && jen.prop("astNode", renderAstNode(type.astNode)),
-        ]))).as.add(this._gql("GraphQLObjectType"));
+        return jen.new
+            .add(this._gql("GraphQLObjectType"))
+            .call(jen.obj(jen.prop("name", jen.lit(type.name)), jen.prop("fields", this._renderFieldsThunk(type, inputFieldDirectives, includeAstNodes, !this._includeSubscriptionFieldResolvers && type.name === "Subscription")), ...truthify([
+            type.description &&
+                jen.prop("description", jen.lit(type.description)),
+            typeInterfaces.length &&
+                jen.prop("interfaces", jen.arrow().arr(
+                // do not sort interfaces, the declaration order may be important
+                ...typeInterfaces.map(this._renderGraphQLTypeIdentifier, this))),
+            includeAstNodes &&
+                type.astNode &&
+                jen.prop("astNode", renderAstNode(type.astNode)),
+        ])))
+            .as.add(this._gql("GraphQLObjectType"));
     }
     _renderGraphQLObjectTypeTypes(type) {
         const fieldsWithArgs = Object.values(type.getFields())
@@ -529,7 +624,7 @@ class GeneratorContext {
             jen.export.add(this._renderTypeInterface(type)),
             ...(fieldsWithArgs.length
                 ? [
-                    jen.export.namespace.add(this._renderGraphQLTypeType(type)).block(...fieldsWithArgs.map((field) => jen.export.interface.id(pascalCase(field.name + "_args")).block(...Array.from(field.args)
+                    jen.export.namespace.add(this._renderGraphQLTypeType(type)).block(...fieldsWithArgs.map((field) => jen.export.interface.id(pascalCase(`${field.name}_args`)).block(...Array.from(field.args)
                         .sort(compareName)
                         .map((arg) => jen.prop(arg.name, this._renderOptionalGraphQLTypeType(arg.type)))))),
                 ]
@@ -538,30 +633,64 @@ class GeneratorContext {
     }
     _renderGraphQLScalarTypeDefinition(type) {
         const s = this._scalarsInfo[type.name];
-        return jen.new.add(this._gql("GraphQLScalarType")).call(jen.obj(jen.prop("name", jen.lit(type.name)), ...truthify([
-            type.description && jen.prop("description", jen.lit(type.description)),
-            jen.prop("serialize", s?.serializeFunc ? renderSymbolReference(this._pkgs, s.serializeFunc) : jen.trivia("stub").arrow(jen.id("v")).id("v")),
-            s?.parseValueFunc && jen.prop("parseValue", renderSymbolReference(this._pkgs, s.parseValueFunc)),
-            s?.parseLiteralFunc && jen.prop("parseLiteral", renderSymbolReference(this._pkgs, s.parseLiteralFunc)),
+        return jen.new
+            .add(this._gql("GraphQLScalarType"))
+            .call(jen.obj(jen.prop("name", jen.lit(type.name)), ...truthify([
+            type.description &&
+                jen.prop("description", jen.lit(type.description)),
+            jen.prop("serialize", s?.serializeFunc
+                ? renderSymbolReference(this._pkgs, s.serializeFunc)
+                : jen.trivia("stub").arrow(jen.id("v")).id("v")),
+            s?.parseValueFunc &&
+                jen.prop("parseValue", renderSymbolReference(this._pkgs, s.parseValueFunc)),
+            s?.parseLiteralFunc &&
+                jen.prop("parseLiteral", renderSymbolReference(this._pkgs, s.parseLiteralFunc)),
         ])));
     }
     _renderTypeResolverAndCastFunctions(type, subTypes, prefix) {
         const sortedSubTypes = Array.from(subTypes).sort(compareName);
         return [
-            jen.arrow(jen.prop("v", jen.any)).block(jen.switch(jen.id("v").computed(jen.id(prefix + "Symbol_" + type.name))).block(...sortedSubTypes.map((subType) => jen.case(jen.id(prefix + "TypeSymbol_" + subType.name + "_" + type.name)).return(jen.lit(subType.name)))), jen.return(jen.id("v").dot("__typename"))),
+            jen
+                .arrow(jen.prop("v", jen.any))
+                .block(jen
+                .switch(jen.id("v").computed(jen.id(`${prefix}Symbol_${type.name}`)))
+                .block(...sortedSubTypes.map((subType) => jen
+                .case(jen.id(`${prefix}TypeSymbol_${subType.name}_${type.name}`))
+                .return(jen.lit(subType.name)))), jen.return(jen.id("v").dot("__typename"))),
             [
-                jen.const.id(prefix + "Symbol_" + type.name).op("=").id("Symbol").call(jen.lit(type.name + " type")),
-                ...sortedSubTypes.map((subType) => jen.const.id(prefix + "TypeSymbol_" + subType.name + "_" + type.name).op("=").id("Symbol").call(jen.lit(subType.name + " " + type.name))),
-                ...sortedSubTypes.map((subType) => jen.export.const.id("as" + subType.name + type.name).op("=").types(jen.id("T")).params(jen.prop("v", jen.any)).op(":").intersect(jen.id("T"), jen.obj(jen.prop(jen.computed(jen.id(prefix + "Symbol_" + type.name)), jen.symbol))).op("=>")
-                    .parens(jen.obj(jen.spread(jen.id("v")), jen.prop(jen.computed(jen.id(prefix + "Symbol_" + type.name)), jen.id(prefix + "TypeSymbol_" + subType.name + "_" + type.name))))),
+                jen.const
+                    .id(`${prefix}Symbol_${type.name}`)
+                    .op("=")
+                    .id("Symbol")
+                    .call(jen.lit(`${type.name} type`)),
+                ...sortedSubTypes.map((subType) => jen.const
+                    .id(`${prefix}TypeSymbol_${subType.name}_${type.name}`)
+                    .op("=")
+                    .id("Symbol")
+                    .call(jen.lit(`${subType.name} ${type.name}`))),
+                ...sortedSubTypes.map((subType) => jen.export.const
+                    .id(`as${subType.name}${type.name}`)
+                    .op("=")
+                    .types(jen.id("T"))
+                    .params(jen.prop("v", jen.any))
+                    .op(":")
+                    .intersect(jen.id("T"), jen.obj(jen.prop(jen.computed(jen.id(`${prefix}Symbol_${type.name}`)), jen.symbol)))
+                    .op("=>")
+                    .parens(jen.obj(jen.spread(jen.id("v")), jen.prop(jen.computed(jen.id(`${prefix}Symbol_${type.name}`)), jen.id(`${prefix}TypeSymbol_${subType.name}_${type.name}`))))),
             ],
         ];
     }
     _renderGraphQLInterfaceTypeDefinition(type, { inputFieldDirectives, includeAstNodes }) {
-        return jen.new.add(this._gql("GraphQLInterfaceType")).call(jen.obj(jen.prop("name", jen.lit(type.name)), jen.prop("fields", this._renderFieldsThunk(type, inputFieldDirectives, includeAstNodes)), ...truthify([
-            type.description && jen.prop("description", jen.lit(type.description)),
-            includeAstNodes && type.astNode && jen.prop("astNode", renderAstNode(type.astNode)),
-        ]))).as.add(this._gql("GraphQLInterfaceType"));
+        return jen.new
+            .add(this._gql("GraphQLInterfaceType"))
+            .call(jen.obj(jen.prop("name", jen.lit(type.name)), jen.prop("fields", this._renderFieldsThunk(type, inputFieldDirectives, includeAstNodes)), ...truthify([
+            type.description &&
+                jen.prop("description", jen.lit(type.description)),
+            includeAstNodes &&
+                type.astNode &&
+                jen.prop("astNode", renderAstNode(type.astNode)),
+        ])))
+            .as.add(this._gql("GraphQLInterfaceType"));
     }
     _renderGraphQLInterfaceTypeTypes(type, { implementors: { implementors } }) {
         const fieldsWithArgs = Object.values(type.getFields())
@@ -569,30 +698,55 @@ class GeneratorContext {
             .sort(compareName);
         return [
             jen.export.add(this._renderTypeInterface(type)),
-            jen.export.namespace.id(type.name).block(...implementors.map((implementor) => jen.export.const.id("as" + pascalCase(implementor.name)).op("=")
-                .types(jen.id("T")).params(jen.prop("v", jen.id("T"))).op("=>").id("setTypename").call(jen.id("v"), jen.lit(implementor.name))), ...fieldsWithArgs.map((field) => jen.export.interface.id(pascalCase(field.name + "_args")).block(...Array.from(field.args)
+            jen.export.namespace.id(type.name).block(...implementors.map((implementor) => jen.export.const
+                .id(`as${pascalCase(implementor.name)}`)
+                .op("=")
+                .types(jen.id("T"))
+                .params(jen.prop("v", jen.id("T")))
+                .op("=>")
+                .id("setTypename")
+                .call(jen.id("v"), jen.lit(implementor.name))), ...fieldsWithArgs.map((field) => jen.export.interface.id(pascalCase(`${field.name}_args`)).block(...Array.from(field.args)
                 .sort(compareName)
                 .map((arg) => jen.prop(arg.name, this._renderOptionalGraphQLTypeType(arg.type)))))),
         ];
     }
     _renderGraphQLUnionTypeDefinition(type) {
-        return jen.new.add(this._gql("GraphQLUnionType")).call(jen.obj(jen.prop("name", jen.lit(type.name)), jen.prop("types", jen.arrow().array(...type.getTypes().map((type) => this._renderGraphQLTypeIdentifier(type)))), ...truthify([
-            type.description && jen.prop("description", jen.lit(type.description)),
+        return jen.new
+            .add(this._gql("GraphQLUnionType"))
+            .call(jen.obj(jen.prop("name", jen.lit(type.name)), jen.prop("types", jen
+            .arrow()
+            .array(...type
+            .getTypes()
+            .map((type) => this._renderGraphQLTypeIdentifier(type)))), ...truthify([
+            type.description &&
+                jen.prop("description", jen.lit(type.description)),
         ])));
     }
     _renderGraphQLUnionTypeTypes(type) {
         return [
-            jen.export.type.add(this._renderGraphQLTypeType(type)).op("=").union(...Array.from(type.getTypes()).sort(compareName).map(this._renderGraphQLTypeType, this)),
-            jen.export.namespace.id(type.name).block(...type.getTypes().map((type) => jen.export.const.id("as" + pascalCase(type.name)).op("=")
-                .types(jen.id("T")).params(jen.prop("v", jen.id("T"))).op("=>").id("setTypename").call(jen.id("v"), jen.lit(type.name)))),
+            jen.export.type
+                .add(this._renderGraphQLTypeType(type))
+                .op("=")
+                .union(...Array.from(type.getTypes())
+                .sort(compareName)
+                .map(this._renderGraphQLTypeType, this)),
+            jen.export.namespace.id(type.name).block(...type.getTypes().map((type) => jen.export.const
+                .id(`as${pascalCase(type.name)}`)
+                .op("=")
+                .types(jen.id("T"))
+                .params(jen.prop("v", jen.id("T")))
+                .op("=>")
+                .id("setTypename")
+                .call(jen.id("v"), jen.lit(type.name)))),
         ];
     }
     _findInputDirectiveInfoFromArgOrField(field, inputFieldDirectives) {
         const fieldTypeName = graphql.getNamedType(field.type).name;
         let transform;
-        if (inputFieldDirectives[fieldTypeName] && Object.keys(inputFieldDirectives[fieldTypeName]).length) {
+        if (inputFieldDirectives[fieldTypeName] &&
+            Object.keys(inputFieldDirectives[fieldTypeName]).length) {
             transform = {
-                symbol: "transform" + fieldTypeName,
+                symbol: `transform${fieldTypeName}`,
             };
         }
         if (field.astNode?.directives?.length) {
@@ -612,9 +766,7 @@ class GeneratorContext {
         }
     }
     _renderInputFieldsWithDirectives(valueExpr, fieldsWithDirectives, spread) {
-        return jen.obj(...truthify([
-            spread && jen.spread(valueExpr),
-        ]), ...fieldsWithDirectives.map(({ field, directives, transform }) => {
+        return jen.obj(...truthify([spread && jen.spread(valueExpr)]), ...fieldsWithDirectives.map(({ field, directives, transform }) => {
             const fieldExpr = valueExpr.dot(field.name);
             const nullableType = graphql.getNullableType(field.type);
             let transformedExpr;
@@ -631,50 +783,107 @@ class GeneratorContext {
                 transformedExpr = renderSymbolReference(this._pkgs, ref).call(transformedExpr, this._renderArgumentNodes(args));
             }
             if (nullableType instanceof graphql.GraphQLList) {
-                transformedExpr = jen.id("Array").dot("from").call(valueExpr.dot(field.name), jen.arrow(jen.id("elem")).add(transformedExpr));
+                transformedExpr = jen
+                    .id("Array")
+                    .dot("from")
+                    .call(valueExpr.dot(field.name), jen.arrow(jen.id("elem")).add(transformedExpr));
                 if (!(field.type instanceof graphql.GraphQLNonNull)) {
-                    transformedExpr = jen.cond(valueExpr.dot(field.name).op("===").null.op("||").add(valueExpr).dot(field.name).op("===").undefined, jen.undefined, transformedExpr);
+                    transformedExpr = jen.cond(valueExpr
+                        .dot(field.name)
+                        .op("===")
+                        .null.op("||")
+                        .add(valueExpr)
+                        .dot(field.name)
+                        .op("===").undefined, jen.undefined, transformedExpr);
                 }
             }
             return jen.prop(field.name, transformedExpr);
         }));
     }
     _renderGraphQLInputObjectTypeDefinition(type, { inputFieldDirectives, includeAstNodes }) {
-        return jen.new.add(this._gql("GraphQLInputObjectType")).call(jen.obj(jen.prop("name", jen.lit(type.name)), jen.prop("fields", this._renderFieldsThunk(type, inputFieldDirectives, includeAstNodes, true)), ...truthify([
-            type.description && jen.prop("description", jen.lit(type.description)),
-            includeAstNodes && type.astNode && jen.prop("astNode", renderAstNode(type.astNode)),
+        return jen.new
+            .add(this._gql("GraphQLInputObjectType"))
+            .call(jen.obj(jen.prop("name", jen.lit(type.name)), jen.prop("fields", this._renderFieldsThunk(type, inputFieldDirectives, includeAstNodes, true)), ...truthify([
+            type.description &&
+                jen.prop("description", jen.lit(type.description)),
+            includeAstNodes &&
+                type.astNode &&
+                jen.prop("astNode", renderAstNode(type.astNode)),
         ])));
     }
     _renderGraphQLInputObjectTypeTypes(type, { inputFieldDirectives }) {
-        const fieldsWithDirectives = truthify(Object.values(type.getFields())
-            .map((f) => this._findInputDirectiveInfoFromArgOrField(f, inputFieldDirectives)));
+        const fieldsWithDirectives = truthify(Object.values(type.getFields()).map((f) => this._findInputDirectiveInfoFromArgOrField(f, inputFieldDirectives)));
         return [
             jen.export.interface.add(this._renderGraphQLTypeType(type)).block(...Object.values(type.getFields())
                 .sort(compareName)
                 .map((field) => jen.prop(field.name, this._renderOptionalGraphQLTypeType(field.type)))),
             ...truthify([
                 fieldsWithDirectives.length &&
-                    jen.const.id("transform" + this._deriveGraphQLTypeName(type)).op("=").types(jen.id("T").extends.union(jen.id(type.name), jen.undefined)).params(jen.prop("v", jen.id("T")))
-                        .op(":").id("T").op("=>").parens(jen.id("v").op("&&").add(this._renderInputFieldsWithDirectives(jen.id("v"), fieldsWithDirectives, fieldsWithDirectives.length < Object.keys(type.getFields()).length))),
+                    jen.const
+                        .id(`transform${this._deriveGraphQLTypeName(type)}`)
+                        .op("=")
+                        .types(jen.id("T").extends.union(jen.id(type.name), jen.undefined))
+                        .params(jen.prop("v", jen.id("T")))
+                        .op(":")
+                        .id("T")
+                        .op("=>")
+                        .parens(jen
+                        .id("v")
+                        .op("&&")
+                        .add(this._renderInputFieldsWithDirectives(jen.id("v"), fieldsWithDirectives, fieldsWithDirectives.length <
+                        Object.keys(type.getFields()).length))),
             ]),
         ];
     }
     _renderGraphQLEnumTypeDefinition(type) {
         const sortedValues = Array.from(type.getValues()).sort(compareName);
-        return jen.new.add(this._gql("GraphQLEnumType")).call(jen.obj(jen.prop("name", jen.lit(type.name)), jen.prop("values", jen.obj(...sortedValues.map((e) => jen.prop(e.name, jen.obj(jen.prop("value", jen.lit(e.value)), ...truthify([
-            e.description && jen.prop("description", jen.lit(e.description)),
-            e.deprecationReason && jen.prop("deprecationReason", jen.lit(e.deprecationReason)),
+        return jen.new
+            .add(this._gql("GraphQLEnumType"))
+            .call(jen.obj(jen.prop("name", jen.lit(type.name)), jen.prop("values", jen.obj(...sortedValues.map((e) => jen.prop(e.name, jen.obj(jen.prop("value", jen.lit(e.value)), ...truthify([
+            e.description &&
+                jen.prop("description", jen.lit(e.description)),
+            e.deprecationReason &&
+                jen.prop("deprecationReason", jen.lit(e.deprecationReason)),
         ])))))), ...truthify([
-            type.description && jen.prop("description", jen.lit(type.description)),
+            type.description &&
+                jen.prop("description", jen.lit(type.description)),
         ])));
     }
     _renderGraphQLEnumTypeTypes(type) {
         const sortedValues = Array.from(type.getValues()).sort(compareName);
         return [
-            jen.export.enum.add(this._renderGraphQLTypeType(type)).obj(...sortedValues.map(({ name }) => jen.id(name).op("=").lit(name))),
-            jen.export.function(jen.id("is" + this._deriveGraphQLTypeName(type)), jen.prop("v", jen.id("any"))).op(":").id("v").is.add(this._renderGraphQLTypeType(type)).block(jen.return(jen.id("v").in.add(this._renderGraphQLTypeType(type)))),
+            jen.export.enum
+                .add(this._renderGraphQLTypeType(type))
+                .obj(...sortedValues.map(({ name }) => jen.id(name).op("=").lit(name))),
+            jen.export
+                .function(jen.id(`is${this._deriveGraphQLTypeName(type)}`), jen.prop("v", jen.id("any")))
+                .op(":")
+                .id("v")
+                .is.add(this._renderGraphQLTypeType(type))
+                .block(jen.return(jen.id("v").in.add(this._renderGraphQLTypeType(type)))),
         ];
     }
+    _getGraphQLTypeClass(type) {
+        if (type instanceof graphql.GraphQLObjectType) {
+            return 'GraphQLObjectType';
+        }
+        if (type instanceof graphql.GraphQLScalarType) {
+            return 'GraphQLScalarType';
+        }
+        if (type instanceof graphql.GraphQLInterfaceType) {
+            return 'GraphQLInterfaceType';
+        }
+        if (type instanceof graphql.GraphQLUnionType) {
+            return 'GraphQLUnionType';
+        }
+        if (type instanceof graphql.GraphQLInputObjectType) {
+            return 'GraphQLInputObjectType';
+        }
+        if (type instanceof graphql.GraphQLEnumType) {
+            return 'GraphQLEnumType';
+        }
+        throw new Error(`unhandled type: ${type.toString()}`);
+    }
     _getRenderDefintionFnForType(type) {
         if (type instanceof graphql.GraphQLObjectType) {
             return this._renderGraphQLObjectTypeDefinition.bind(this, type);
@@ -694,7 +903,7 @@ class GeneratorContext {
         if (type instanceof graphql.GraphQLEnumType) {
             return this._renderGraphQLEnumTypeDefinition.bind(this, type);
         }
-        throw new Error("unhandled type: " + type.toString());
+        throw new Error(`unhandled type: ${type.toString()}`);
     }
     _getRenderTypesFnForType(type) {
         if (type instanceof graphql.GraphQLObjectType) {
@@ -715,10 +924,15 @@ class GeneratorContext {
         if (type instanceof graphql.GraphQLEnumType) {
             return this._renderGraphQLEnumTypeTypes.bind(this, type);
         }
-        throw new Error("unhandled type: " + type.toString());
+        throw new Error(`unhandled type: ${type.toString()}`);
     }
     _renderGraphQLTypeDefinitions(type, interfaces, inputFieldDirectives, includeAstNodes) {
-        return jen.const.add(this._renderGraphQLTypeIdentifier(type)).op("=").add(this._getRenderDefintionFnForType(type)({
+        return jen.const
+            .add(this._renderGraphQLTypeIdentifier(type))
+            .op(":")
+            .id(this._getGraphQLTypeClass(type))
+            .op("=")
+            .add(this._getRenderDefintionFnForType(type)({
             implementors: interfaces[type.name],
             inputFieldDirectives,
             includeAstNodes,
@@ -731,54 +945,101 @@ class GeneratorContext {
         });
     }
     _renderGraphQLDirectiveDefinition(directive, includeAstNodes) {
-        return jen.const.add(this._renderGraphQLTypeIdentifier(directive)).op("=").new.add(this._gql("GraphQLDirective"))
-            .call(jen.obj(jen.prop("name", jen.lit(directive.name)), jen.prop("locations", jen.array(...Array.from(directive.locations).sort().map((location) => jen.add(this._gql("DirectiveLocation")).dot(location)))), jen.prop("args", this._renderArgumentsObject(directive.args)), ...truthify([
-            directive.description && jen.prop("description", jen.lit(directive.description)),
+        return jen.const
+            .add(this._renderGraphQLTypeIdentifier(directive))
+            .op("=")
+            .new.add(this._gql("GraphQLDirective"))
+            .call(jen.obj(jen.prop("name", jen.lit(directive.name)), jen.prop("locations", jen.array(...Array.from(directive.locations)
+            .sort()
+            .map((location) => jen.add(this._gql("DirectiveLocation")).dot(location)))), jen.prop("args", this._renderArgumentsObject(directive.args)), ...truthify([
+            directive.description &&
+                jen.prop("description", jen.lit(directive.description)),
             directive.isRepeatable && jen.prop("isRepeatable", jen.true),
-            includeAstNodes && directive.astNode && jen.prop("astNode", renderAstNode(directive.astNode)),
+            includeAstNodes &&
+                directive.astNode &&
+                jen.prop("astNode", renderAstNode(directive.astNode)),
         ])));
     }
     _renderGraphQLDirectiveTypes(directive) {
         return truthify([
-            directive.args.length && jen.export.interface.id(pascalCase(directive.name + "_directive_args")).block(...directive.args.map((arg) => jen.prop(jen.id(arg.name).add(...truthify([
-                !(arg.type instanceof graphql.GraphQLNonNull) && jen.op("?"),
-            ])), this._renderGraphQLTypeType(arg.type)))),
+            directive.args.length &&
+                jen.export.interface
+                    .id(pascalCase(`${directive.name}_directive_args`))
+                    .block(...directive.args.map((arg) => jen.prop(jen
+                    .id(arg.name)
+                    .add(...truthify([
+                    !(arg.type instanceof graphql.GraphQLNonNull) && jen.op("?"),
+                ])), this._renderGraphQLTypeType(arg.type)))),
         ]);
     }
     schemaExprs(schema, [types, interfaces, inputFieldDirectives, includeAstNodes]) {
+        const queryType = schema.getQueryType();
+        const mutationType = schema.getMutationType();
+        const subscriptionType = schema.getSubscriptionType();
         return [
             ...[
                 // render type definitions
                 ...types
-                    .map((type) => [type.name, this._renderGraphQLTypeDefinitions(type, interfaces, inputFieldDirectives, includeAstNodes)])
+                    .map((type) => [
+                    type.name,
+                    this._renderGraphQLTypeDefinitions(type, interfaces, inputFieldDirectives, includeAstNodes),
+                ])
                     .sort(compareEntryKey),
                 // render directive definitions
-                ...schema.getDirectives()
+                ...schema
+                    .getDirectives()
                     .filter((d) => !isBuiltInDirective(d.name))
-                    .map((directive) => [directive.name, this._renderGraphQLDirectiveDefinition(directive)])
+                    .map((directive) => [
+                    directive.name,
+                    this._renderGraphQLDirectiveDefinition(directive),
+                ])
                     .sort(compareEntryKey),
             ].map(([, expr]) => expr),
-            ...Array.from(PRIMITIVE_TYPES)
-                .flatMap((type) => {
+            ...Array.from(PRIMITIVE_TYPES).flatMap((type) => {
                 const info = this._scalarsInfo[type];
                 if (!info) {
                     return [];
                 }
                 return [
                     jen.statements(...[
-                        info.serializeFunc && this._gql("GraphQL" + type).dot("serialize").op("=").parens(renderSymbolReference(this._pkgs, info.serializeFunc).as.any),
-                        info.parseValueFunc && this._gql("GraphQL" + type).dot("parseValue").op("=").parens(renderSymbolReference(this._pkgs, info.parseValueFunc).as.any),
-                        info.parseLiteralFunc && this._gql("GraphQL" + type).dot("parseLiteral").op("=").parens(renderSymbolReference(this._pkgs, info.parseLiteralFunc).as.any),
-                    ].filter(Boolean))
+                        info.serializeFunc &&
+                            this._gql(`GraphQL${type}`)
+                                .dot("serialize")
+                                .op("=")
+                                .parens(renderSymbolReference(this._pkgs, info.serializeFunc).as
+                                .any),
+                        info.parseValueFunc &&
+                            this._gql(`GraphQL${type}`)
+                                .dot("parseValue")
+                                .op("=")
+                                .parens(renderSymbolReference(this._pkgs, info.parseValueFunc).as
+                                .any),
+                        info.parseLiteralFunc &&
+                            this._gql(`GraphQL${type}`)
+                                .dot("parseLiteral")
+                                .op("=")
+                                .parens(renderSymbolReference(this._pkgs, info.parseLiteralFunc).as
+                                .any),
+                    ].filter(Boolean)),
                 ];
             }),
             // render schema
-            jen.const.id("schema").op("=").new.add(this._gql("GraphQLSchema")).call(jen.obj(...(schema.getQueryType()
-                ? [jen.prop("query", this._renderGraphQLTypeIdentifier(schema.getQueryType()))]
-                : []), ...(schema.getMutationType()
-                ? [jen.prop("mutation", this._renderGraphQLTypeIdentifier(schema.getMutationType()))]
-                : []), ...(schema.getSubscriptionType()
-                ? [jen.prop("subscription", this._renderGraphQLTypeIdentifier(schema.getSubscriptionType()))]
+            jen.const
+                .id("schema")
+                .op("=")
+                .new.add(this._gql("GraphQLSchema"))
+                .call(jen.obj(...(queryType
+                ? [
+                    jen.prop("query", this._renderGraphQLTypeIdentifier(queryType)),
+                ]
+                : []), ...(mutationType
+                ? [
+                    jen.prop("mutation", this._renderGraphQLTypeIdentifier(mutationType)),
+                ]
+                : []), ...(subscriptionType
+                ? [
+                    jen.prop("subscription", this._renderGraphQLTypeIdentifier(subscriptionType)),
+                ]
                 : []), jen.prop("types", jen.array(...types.map((type) => this._renderGraphQLTypeIdentifier(type)))), jen.prop("directives", jen.array(...Array.from(schema.getDirectives())
                 .filter((d) => !isBuiltInDirective(d.name))
                 .map((d) => this._renderGraphQLTypeIdentifier(d)))))),
@@ -787,15 +1048,44 @@ class GeneratorContext {
     }
     typesExprs(schema, [types, interfaces, inputFieldDirectives]) {
         return [
-            ["", jen.const.id("setTypename").op("=").types(jen.id("T")).params(jen.id("v").op(":").id("T"), jen.id("t").op(":").string).op(":").id("T").op("=>").block(jen.if(jen.op("!").id("v").op("||").typeof(jen.id("v")).op("!==").lit("object")).block(jen.throw.new.id("Error").call(jen.lit("expected object"))), jen.return(jen.id("Object").dot("assign").call(jen.id("v"), jen.obj(jen.prop(jen.id("__typename"), jen.id("t"))))))],
+            [
+                "",
+                jen.const
+                    .id("setTypename")
+                    .op("=")
+                    .types(jen.id("T"))
+                    .params(jen.id("v").op(":").id("T"), jen.id("t").op(":").string)
+                    .op(":")
+                    .id("T")
+                    .op("=>")
+                    .block(jen
+                    .if(jen
+                    .op("!")
+                    .id("v")
+                    .op("||")
+                    .typeof(jen.id("v"))
+                    .op("!==")
+                    .lit("object"))
+                    .block(jen.throw.new.id("Error").call(jen.lit("expected object"))), jen.return(jen
+                    .id("Object")
+                    .dot("assign")
+                    .call(jen.id("v"), jen.obj(jen.prop(jen.id("__typename"), jen.id("t")))))),
+            ],
             // render type definitions
             ...types
-                .map((type) => [type.name, jen.statements(...this._renderGraphQLTypeTypes(type, interfaces, inputFieldDirectives))])
+                .map((type) => [
+                type.name,
+                jen.statements(...this._renderGraphQLTypeTypes(type, interfaces, inputFieldDirectives)),
+            ])
                 .sort(compareEntryKey),
             // render directive definitions
-            ...schema.getDirectives()
+            ...schema
+                .getDirectives()
                 .filter((d) => !isBuiltInDirective(d.name))
-                .map((directive) => [directive.name, jen.statements(...this._renderGraphQLDirectiveTypes(directive))])
+                .map((directive) => [
+                directive.name,
+                jen.statements(...this._renderGraphQLDirectiveTypes(directive)),
+            ])
                 .sort(compareEntryKey),
         ].map(([, expr]) => expr);
     }
@@ -809,7 +1099,9 @@ class GeneratorContext {
         const base = outfile.startsWith("/") ? outfile : path.resolve(outfile);
         const statements = renderStatements.call(this);
         const [localImports, externalImports] = partition(Object.entries(this._pkgs.requires), ([pkg]) => pkg.startsWith("/"));
-        return format(jen.statements(renderImports(path.dirname(base), externalImports, this._pkgs.aliases, this._extMode), renderImports(path.dirname(base), localImports, this._pkgs.aliases, this._extMode), ...statements).toString());
+        return format(jen
+            .statements(renderImports(path.dirname(base), externalImports, this._pkgs.aliases, this._extMode), renderImports(path.dirname(base), localImports, this._pkgs.aliases, this._extMode), ...statements)
+            .toString());
     }
     static prepareInterfacesAndInputFieldDirectives(schema, options = {}) {
         if (options.fieldDirectivesInfo) {
@@ -837,7 +1129,11 @@ class GeneratorContext {
                 }
                 for (const field of Object.values(type.getFields())) {
                     if (graphql.getNamedType(field.type) instanceof graphql.GraphQLInputObjectType) {
-                        typesWithObjectFields.push([type.name, field.name, graphql.getNamedType(field.type).name]);
+                        typesWithObjectFields.push([
+                            type.name,
+                            field.name,
+                            graphql.getNamedType(field.type).name,
+                        ]);
                     }
                     const directives = field.astNode?.directives;
                     if (!directives) {
@@ -848,22 +1144,34 @@ class GeneratorContext {
                         if (!options.inputDirectivesInfo[name]) {
                             continue;
                         }
-                        const fieldDirectives = inputFieldDirectives[type.name] ?? (inputFieldDirectives[type.name] = {});
-                        const fieldDirective = fieldDirectives[field.name] ?? (fieldDirectives[field.name] = []);
-                        fieldDirective.push(name);
+                        if (!inputFieldDirectives[type.name]) {
+                            inputFieldDirectives[type.name] = {};
+                        }
+                        const fieldDirectives = inputFieldDirectives[type.name];
+                        if (!fieldDirectives[field.name]) {
+                            fieldDirectives[field.name] = [];
+                        }
+                        fieldDirectives[field.name].push(name);
                     }
                 }
             }
             for (let changes = 1; changes; changes = 0) {
                 const newTypesWithObjectFields = new Array();
-                for (const [typeName, fieldName, objectTypeName] of typesWithObjectFields) {
+                for (const [typeName, fieldName, objectTypeName,] of typesWithObjectFields) {
                     console.log(`checking ${typeName}.${fieldName} for ${objectTypeName}`);
                     if (inputFieldDirectives[objectTypeName]) {
-                        inputFieldDirectives[typeName] = { ...inputFieldDirectives[typeName], [fieldName]: [] };
+                        inputFieldDirectives[typeName] = {
+                            ...inputFieldDirectives[typeName],
+                            [fieldName]: [],
+                        };
                         changes += 1;
                     }
                     else {
-                        newTypesWithObjectFields.push([typeName, fieldName, objectTypeName]);
+                        newTypesWithObjectFields.push([
+                            typeName,
+                            fieldName,
+                            objectTypeName,
+                        ]);
                     }
                 }
                 typesWithObjectFields = newTypesWithObjectFields;
@@ -884,7 +1192,12 @@ class GeneratorContext {
                 interfaces[iface.name].implementors.push(type);
             }
         }
-        return [types, interfaces, inputFieldDirectives, options.includeAstNodes];
+        return [
+            types,
+            interfaces,
+            inputFieldDirectives,
+            options.includeAstNodes,
+        ];
     }
 }
 function createGenerator(schema, options) {
@@ -924,8 +1237,8 @@ function createMatcher(pattern) {
     if (typeof pattern === "string") {
         return pm(pattern);
     }
-    let matchers = [];
-    let globs = [];
+    const matchers = [];
+    const globs = [];
     for (const p of Array.isArray(pattern) ? pattern : [pattern]) {
         if (typeof p === "string") {
             globs.push(p);
@@ -947,9 +1260,9 @@ function createMatcher(pattern) {
 }
 
 async function parseResolverFile(path) {
-    return Object.fromEntries(Object.entries((await parseModule(path)).exports)
-        .flatMap(([name, decls]) => decls.flatMap(({ declaration }) => {
-        if (ts.isVariableDeclaration(declaration) && declaration.initializer) {
+    return Object.fromEntries(Object.entries((await parseModule(path)).exports).flatMap(([name, decls]) => decls.flatMap(({ declaration }) => {
+        if (ts.isVariableDeclaration(declaration) &&
+            declaration.initializer) {
             if (ts.isFunctionExpression(declaration.initializer)) {
                 return [[name, { module: path, symbol: name }]];
             }
@@ -968,14 +1281,18 @@ async function parseTypeResolvers(typeName, glob$1, ignore) {
     const result = {};
     for await (const entry of glob.globIterate(glob$1, { withFileTypes: true })) {
         const fullpath = entry.fullpath();
-        if (!shouldIgnore(fullpath) && entry.isFile() && entry.name.endsWith(".ts")) {
+        if (!shouldIgnore(fullpath) &&
+            entry.isFile() &&
+            entry.name.endsWith(".ts")) {
             for (const [name, reference] of Object.entries(await parseResolverFile(fullpath))) {
                 let realName = name;
-                if (realName === "default" && typeof glob$1 === 'string' && glob$1.endsWith('/*.ts')) {
+                if (realName === "default" &&
+                    typeof glob$1 === "string" &&
+                    glob$1.endsWith("/*.ts")) {
                     realName = path.basename(fullpath, path.extname(fullpath));
                 }
                 if (realName in result) {
-                    console.warn(`WARNING: Duplicate resolver name: ${typeName ? typeName + "." : ""}${name} in ${fullpath} and ${result[name].module}`);
+                    console.warn(`WARNING: Duplicate resolver name: ${typeName ? `${typeName}.` : ""}${name} in ${fullpath} and ${result[name].module}`);
                 }
                 result[realName] = reference;
             }
@@ -988,16 +1305,13 @@ async function parse$2(dirpath, ignore) {
     if (!dir.isDirectory()) {
         throw new Error(`Expected ${dirpath} to be a directory`);
     }
-    if (!dirpath.endsWith("/")) {
-        dirpath += "/";
-    }
     const out = {};
     const shouldIgnore = createMatcher(ignore);
     for await (const name of await fs.readdir(dirpath)) {
         const file = path.join(dirpath, name);
         const entry = await fs.stat(file);
         if (entry.isDirectory()) {
-            out[name] = await parseTypeResolvers(name, file + "/*.ts", shouldIgnore);
+            out[name] = await parseTypeResolvers(name, `${file}/*.ts`, shouldIgnore);
         }
         else if (entry.isFile() && name.endsWith(".ts")) {
             out[name.slice(0, -3)] = await parseTypeResolvers(name.slice(0, -3), file, shouldIgnore);
@@ -1022,7 +1336,8 @@ function refFromImportTypeNode(node, source) {
         console.log("WARNING: namespace import for scalar type is not supported");
         return;
     }
-    if (!ts.isLiteralTypeNode(node.argument) || !ts.isStringLiteral(node.argument.literal)) {
+    if (!ts.isLiteralTypeNode(node.argument) ||
+        !ts.isStringLiteral(node.argument.literal)) {
         // this is a grammar error, handling it is out of scope
         const { line, character } = ts.getLineAndCharacterOfPosition(source, node.pos);
         console.log(`WARNING: grammar error at ${source.fileName}:${line + 1}:${character + 1}`);
@@ -1037,8 +1352,8 @@ function refFromTypeReferenceNode(typeNode, source) {
     }
     const typeName = typeNode.typeName.text;
     if (typeNode.typeArguments?.length) {
-        if (typeName !== 'Promise') {
-            throw new Error('TODO: handle type arguments');
+        if (typeName !== "Promise") {
+            throw new Error("TODO: handle type arguments");
         }
         return refFromTypeNode(typeNode.typeArguments[0], source);
     }
@@ -1056,7 +1371,11 @@ function refFromTypeReferenceNode(typeNode, source) {
             if (statement.importClause.name) {
                 // default import
                 if (statement.importClause.name.text === typeName) {
-                    return { module: statement.importClause.name.text, symbol: 'default', alias: typeName };
+                    return {
+                        module: statement.importClause.name.text,
+                        symbol: "default",
+                        alias: typeName,
+                    };
                 }
             }
             if (!statement.importClause.namedBindings) {
@@ -1067,17 +1386,24 @@ function refFromTypeReferenceNode(typeNode, source) {
                 // TODO: handle namespace imports (will need to check if `typeName` has a dot in it)
                 continue;
             }
-            for (const specifier of statement.importClause.namedBindings.elements ?? []) {
+            for (const specifier of statement.importClause.namedBindings.elements ??
+                []) {
                 if (specifier.name.text === typeName) {
-                    return { module: statement.moduleSpecifier.text, symbol: specifier.propertyName?.text ?? typeName, alias: typeName };
+                    return {
+                        module: statement.moduleSpecifier.text,
+                        symbol: specifier.propertyName?.text ?? typeName,
+                        alias: typeName,
+                    };
                 }
             }
         }
-        else if (ts.isTypeAliasDeclaration(statement) || ts.isInterfaceDeclaration(statement) || ts.isEnumDeclaration(statement)) {
+        else if (ts.isTypeAliasDeclaration(statement) ||
+            ts.isInterfaceDeclaration(statement) ||
+            ts.isEnumDeclaration(statement)) {
             if (statement.name.text === typeName) {
                 if (!statement.modifiers?.some((mod) => mod.kind === ts.SyntaxKind.ExportKeyword)) {
                     console.log(statement);
-                    console.log(`WARNING: found type ${typeName} in ${source.fileName}:${locLineColumn$1(statement, source).join(':')} but it is not exported`);
+                    console.log(`WARNING: found type ${typeName} in ${source.fileName}:${locLineColumn$1(statement, source).join(":")} but it is not exported`);
                     continue;
                 }
                 return { module: source.fileName, symbol: typeName };
@@ -1091,16 +1417,14 @@ function refFromTypeNode(typeNode, source) {
     if (ts.isImportTypeNode(typeNode)) {
         return refFromImportTypeNode(typeNode, source);
     }
-    else if (ts.isTokenKind(typeNode.kind)) {
+    if (ts.isTokenKind(typeNode.kind)) {
         // primitive type string, number, etc...
         return { symbol: typeNode.getText(source) };
     }
-    else if (ts.isTypeReferenceNode(typeNode)) {
+    if (ts.isTypeReferenceNode(typeNode)) {
         return refFromTypeReferenceNode(typeNode, source);
     }
-    else {
-        console.warn("WARNING: unexpected type node: " + ts.SyntaxKind[typeNode.kind]);
-    }
+    console.warn(`WARNING: unexpected type node: ${ts.SyntaxKind[typeNode.kind]}`);
 }
 function reconcileScalarType(scalarName, typeDecls, source) {
     let type;
@@ -1108,7 +1432,7 @@ function reconcileScalarType(scalarName, typeDecls, source) {
         if (!typeNode) {
             continue;
         }
-        let newType = refFromTypeNode(typeNode, source);
+        const newType = refFromTypeNode(typeNode, source);
         if (type && newType) {
             if (type.symbol !== newType.symbol ||
                 type.alias !== newType.alias ||
@@ -1133,11 +1457,13 @@ function scalarInfoFromObjectLiteralExpression(scalarName, module, properties) {
                 case "serialize":
                 case "parseValue":
                 case "parseLiteral":
-                    if (!ts.isFunctionExpression(prop.initializer) && !ts.isArrowFunction(prop.initializer)) {
+                    if (!ts.isFunctionExpression(prop.initializer) &&
+                        !ts.isArrowFunction(prop.initializer)) {
                         console.log(`WARNING: expected scalar property ${scalarName}.${prop.name.text} to be a function, but got ${ts.SyntaxKind[prop.initializer.kind]}`);
                         return [];
                     }
-                    return [[
+                    return [
+                        [
                             `${prop.name.text}Func`,
                             {
                                 module: module,
@@ -1145,7 +1471,8 @@ function scalarInfoFromObjectLiteralExpression(scalarName, module, properties) {
                                 property: prop.name.text,
                                 declaration: prop.initializer,
                             },
-                        ]];
+                        ],
+                    ];
                 default:
                     console.log(`WARNING: found extraneous scalar property ${scalarName}.${prop.name.text}`);
             }
@@ -1158,7 +1485,8 @@ function scalarInfoFromObjectLiteralExpression(scalarName, module, properties) {
                 case "serialize":
                 case "parseValue":
                 case "parseLiteral":
-                    return [[
+                    return [
+                        [
                             `${prop.name.text}Func`,
                             {
                                 module,
@@ -1166,7 +1494,8 @@ function scalarInfoFromObjectLiteralExpression(scalarName, module, properties) {
                                 property: prop.name.text,
                                 declaration: prop,
                             },
-                        ]];
+                        ],
+                    ];
                 default:
                     console.log(`WARNING: found extraneous scalar property ${scalarName}.${prop.name.text}`);
             }
@@ -1185,7 +1514,8 @@ async function parse$1(path) {
         for (const { declaration, source } of decls) {
             sources[name] = source;
             if (ts.isVariableDeclaration(declaration)) {
-                if (declaration.initializer && ts.isObjectLiteralExpression(declaration.initializer)) {
+                if (declaration.initializer &&
+                    ts.isObjectLiteralExpression(declaration.initializer)) {
                     scalarFnsInfos[name] = scalarInfoFromObjectLiteralExpression(name, new URL(source.fileName).toString(), declaration.initializer.properties);
                 }
             }
@@ -1202,18 +1532,23 @@ async function parse$1(path) {
         }
     }
     const infos = {};
-    for (const name of new Set([...Object.keys(scalarFnsInfos), ...Object.keys(scalarTypeNodes)])) {
+    for (const name of new Set([
+        ...Object.keys(scalarFnsInfos),
+        ...Object.keys(scalarTypeNodes),
+    ])) {
         const fnsInfo = scalarFnsInfos[name];
         const typeNode = scalarTypeNodes[name];
         const source = sources[name];
-        const type = typeNode ? {
-            module: source.fileName,
-            symbol: name,
-        } : reconcileScalarType(name, [
-            // NOTE: omit serialize input type because it is supposed to be `unknown`
-            fnsInfo?.parseValueFunc?.declaration?.type,
-            fnsInfo?.parseLiteralFunc?.declaration?.type,
-        ], source);
+        const type = typeNode
+            ? {
+                module: source.fileName,
+                symbol: name,
+            }
+            : reconcileScalarType(name, [
+                // NOTE: omit serialize input type because it is supposed to be `unknown`
+                fnsInfo?.parseValueFunc?.declaration?.type,
+                fnsInfo?.parseLiteralFunc?.declaration?.type,
+            ], source);
         if (type) {
             if (type.module) {
                 type.module = new URL(type.module, source.fileName).toString();
@@ -1241,8 +1576,10 @@ function traceLine(loc, prefix = "") {
     return `\n    ${prefix}at file://${loc.source.name}:${locLineColumn(loc).join(":")}`;
 }
 function setTraceToSchema(err, name, loc) {
+    // biome-ignore lint/suspicious/noExplicitAny: hacks
     if (globalThis.Deno) {
         if (loc) {
+            // biome-ignore lint/suspicious/noExplicitAny: hacks
             const trace = err.__callSiteEvals;
             const [lineNumber, columnNumber] = locLineColumn(loc);
             // NOTE: this is deno magic
@@ -1255,7 +1592,7 @@ function setTraceToSchema(err, name, loc) {
                         function: undefined,
                         functionName: name,
                         methodName: null,
-                        fileName: "file://" + loc.source.name,
+                        fileName: `file://${loc.source.name}`,
                         lineNumber,
                         columnNumber,
                         evalOrigin: undefined,
@@ -1299,8 +1636,7 @@ function isListValueNodeEqual(a, b) {
     return zip(a.values, b.values).every(([a, b]) => isValueNodeEqual(a, b));
 }
 function isObjectValueNodeEqual(a, b) {
-    return zip(sortNamedNodes(a.fields), sortNamedNodes(b.fields))
-        .every(([a, b]) => a.name.value === b.name.value && isValueNodeEqual(a.value, b.value));
+    return zip(sortNamedNodes(a.fields), sortNamedNodes(b.fields)).every(([a, b]) => a.name.value === b.name.value && isValueNodeEqual(a.value, b.value));
 }
 function isValueNodeEqual(a, b) {
     if (a === b || (!a && !b)) {
@@ -1368,7 +1704,8 @@ function isInputValueDefinitionNodesEqual(a, b) {
     if (!a || !b || a.length !== b.length) {
         return false;
     }
-    return zip(sortNamedNodes(a), sortNamedNodes(b)).every(([a, b]) => a.name.value === b.name.value && isTypeNodeEqual(a.type, b.type) &&
+    return zip(sortNamedNodes(a), sortNamedNodes(b)).every(([a, b]) => a.name.value === b.name.value &&
+        isTypeNodeEqual(a.type, b.type) &&
         isValueNodeEqual(a.defaultValue, b.defaultValue) &&
         isDirectiveNodesEqual(a.directives, b.directives));
 }
@@ -1379,17 +1716,15 @@ function mergeFieldDefinitionNodes(name, a, b) {
             const prev = fields[f.name.value];
             if (prev) {
                 if (!isInputValueDefinitionNodesEqual(prev.arguments, f.arguments)) {
-                    throw setTraceToSchema(new graphql.GraphQLError(`Cannot merge duplicate field with different arguments: ${name}.${f.name.value}`), name + "." + f.name.value, f.loc);
+                    throw setTraceToSchema(new graphql.GraphQLError(`Cannot merge duplicate field with different arguments: ${name}.${f.name.value}`), `${name}.${f.name.value}`, f.loc);
                 }
                 if (!isTypeNodeEqual(prev.type, f.type)) {
-                    throw setTraceToSchema(new graphql.GraphQLError(`Cannot merge duplicate field with different type: ${name}.${f.name.value}`), name + "." + f.name.value, f.type.loc);
+                    throw setTraceToSchema(new graphql.GraphQLError(`Cannot merge duplicate field with different type: ${name}.${f.name.value}`), `${name}.${f.name.value}`, f.type.loc);
                 }
-                console.warn(`WARNING: there is more than one declaration for ${name}.${f.name.value}` +
-                    traceLine(f.loc) +
-                    traceLine(prev.loc, "previously ") + "\n");
+                console.warn(`WARNING: there is more than one declaration for ${name}.${f.name.value}${traceLine(f.loc)}${traceLine(prev.loc, "previously ")}\n`);
                 fields[f.name.value] = {
                     ...prev,
-                    directives: mergeDirectiveNodes(name + "." + f.name.value, prev.directives, f.directives),
+                    directives: mergeDirectiveNodes(`${name}.${f.name.value}`, prev.directives, f.directives),
                 };
             }
             else {
@@ -1406,17 +1741,15 @@ function mergeInputValueDefinitionNodes(name, a, b) {
             const prev = fields[f.name.value];
             if (prev) {
                 if (!isValueNodeEqual(prev.defaultValue, f.defaultValue)) {
-                    throw setTraceToSchema(new graphql.GraphQLError(`Cannot merge duplicate field with different arguments: ${name}.${f.name.value}`), name + "." + f.name.value, f.loc);
+                    throw setTraceToSchema(new graphql.GraphQLError(`Cannot merge duplicate field with different arguments: ${name}.${f.name.value}`), `${name}.${f.name.value}`, f.loc);
                 }
                 if (!isTypeNodeEqual(prev.type, f.type)) {
-                    throw setTraceToSchema(new graphql.GraphQLError(`Cannot merge duplicate field with different type: ${name}.${f.name.value}`), name + "." + f.name.value, f.type.loc);
+                    throw setTraceToSchema(new graphql.GraphQLError(`Cannot merge duplicate field with different type: ${name}.${f.name.value}`), `${name}.${f.name.value}`, f.type.loc);
                 }
-                console.warn(`WARNING: there is more than one declaration for ${name}.${f.name.value}` +
-                    traceLine(f.loc) +
-                    traceLine(prev.loc, "previously ") + "\n");
+                console.warn(`WARNING: there is more than one declaration for ${name}.${f.name.value}${traceLine(f.loc)}${traceLine(prev.loc, "previously ")}\n`);
                 fields[f.name.value] = {
                     ...prev,
-                    directives: mergeDirectiveNodes(name + "." + f.name.value, prev.directives, f.directives),
+                    directives: mergeDirectiveNodes(`${name}.${f.name.value}`, prev.directives, f.directives),
                 };
             }
             else {
@@ -1441,7 +1774,7 @@ function mergeDirectiveNodes(name, a, b) {
         for (const d of b) {
             if (d.name.value in directives &&
                 !isArgumentNodesEqual(directives[d.name.value].arguments, d.arguments)) {
-                throw setTraceToSchema(new graphql.GraphQLError(`Cannot merge duplicate directive with different arguments: ${name} @${d.name.value}`), name + " @" + d.name.value, d.loc);
+                throw setTraceToSchema(new graphql.GraphQLError(`Cannot merge duplicate directive with different arguments: ${name} @${d.name.value}`), `${name} @${d.name.value}`, d.loc);
             }
             directives[d.name.value] = d;
         }
@@ -1493,9 +1826,9 @@ function mergeUnionTypeDefinitionNodes(a, b) {
 function mergeEnumTypeDefinitionNodes(a, b) {
     const values = namedNodesDict(a.values);
     if (b) {
-        for (const v of (b.values || [])) {
+        for (const v of b.values || []) {
             if (v.name.value in values) {
-                throw setTraceToSchema(new graphql.GraphQLError(`Cannot merge duplicate enum value: ${v.name.value}.${v.name.value}`), v.name.value + "." + v.name.value, v.loc);
+                throw setTraceToSchema(new graphql.GraphQLError(`Cannot merge duplicate enum value: ${v.name.value}.${v.name.value}`), `${v.name.value}.${v.name.value}`, v.loc);
             }
             values[v.name.value] = v;
         }
@@ -1534,7 +1867,7 @@ function mergeDocumentNodes(documentNodes) {
                 case graphql.Kind.UNION_TYPE_EXTENSION:
                 case graphql.Kind.ENUM_TYPE_EXTENSION:
                 case graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION:
-                    throw new Error("unexpected definition kind: " + definition.kind);
+                    throw new Error(`unexpected definition kind: ${definition.kind}`);
             }
             const prevDefinition = definitions[definition.name.value];
             if (!prevDefinition) {
@@ -1547,11 +1880,10 @@ function mergeDocumentNodes(documentNodes) {
             if (prevDefinition.kind === graphql.Kind.DIRECTIVE_DEFINITION) {
                 throw setTraceToSchema(new graphql.GraphQLError(`Cannot merge duplicate directive definitions: ${definition.name.value}`), definition.name.value, definition.loc);
             }
-            if (prevDefinition.description && definition.description &&
+            if (prevDefinition.description &&
+                definition.description &&
                 prevDefinition.description.value !== definition.description.value) {
-                console.warn(`WARNING: different descriptions for type ${prevDefinition.name.value}: ${JSON.stringify(prevDefinition.description.value)} and ${JSON.stringify(definition.description.value)}` +
-                    traceLine(definition.description.loc) +
-                    traceLine(prevDefinition.description.loc, "previously ") + "\n");
+                console.warn(`WARNING: different descriptions for type ${prevDefinition.name.value}: ${JSON.stringify(prevDefinition.description.value)} and ${JSON.stringify(definition.description.value)}${traceLine(definition.description.loc)}${traceLine(prevDefinition.description.loc, "previously ")}\n`);
             }
             switch (definition.kind) {
                 case graphql.Kind.SCALAR_TYPE_DEFINITION:
@@ -1561,7 +1893,8 @@ function mergeDocumentNodes(documentNodes) {
                     definitions[definition.name.value] = mergeObjectTypeDefinitionNodes(prevDefinition, definition);
                     break;
                 case graphql.Kind.INTERFACE_TYPE_DEFINITION:
-                    definitions[definition.name.value] = mergeInterfaceTypeDefinitionNodes(prevDefinition, definition);
+                    definitions[definition.name.value] =
+                        mergeInterfaceTypeDefinitionNodes(prevDefinition, definition);
                     break;
                 case graphql.Kind.UNION_TYPE_DEFINITION:
                     definitions[definition.name.value] = mergeUnionTypeDefinitionNodes(prevDefinition, definition);
@@ -1570,7 +1903,8 @@ function mergeDocumentNodes(documentNodes) {
                     definitions[definition.name.value] = mergeEnumTypeDefinitionNodes(prevDefinition, definition);
                     break;
                 case graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION:
-                    definitions[definition.name.value] = mergeInputObjectTypeDefinitionNodes(prevDefinition, definition);
+                    definitions[definition.name.value] =
+                        mergeInputObjectTypeDefinitionNodes(prevDefinition, definition);
                     break;
             }
         }