graphql-jerky 1.0.0

package/build/lib.cjs

@@ -0,0 +1,1540 @@
+'use strict';
+
+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');
+var zip = require('just-zip-it');
+
+async function parseSource(filepath) {
+    return ts.createSourceFile(filepath.href, await fs.readFile(filepath, "utf-8"), ts.ScriptTarget.ESNext);
+}
+function resolveModule(specifier, referrer) {
+    let url;
+    if (specifier.startsWith(".")) {
+        url = new URL(specifier.replace(/(?<!\.[jt]sx?)$/, ".ts"), referrer);
+    }
+    else {
+        // TODO use import_map.json
+        url = new URL(specifier);
+    }
+    if (url.protocol === "file:") {
+        return parseSource(url);
+    }
+    else {
+        throw new Error(`Unsupported protocol: ${url.protocol}`);
+    }
+}
+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 (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
+                if (node.modifiers.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword)) {
+                    exports.default = { declaration: node, source, name: "default" };
+                }
+                else if (node.name) {
+                    exports[node.name.getText(source)] = { declaration: node, source, name: node.name.getText(source) };
+                }
+            }
+        }
+        else if (ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isModuleDeclaration(node)) {
+            if (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
+                exports[node.name.getText(source)] = { declaration: node, source, name: node.name.getText(source) };
+            }
+        }
+        else if (ts.isVariableStatement(node)) {
+            if (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
+                for (const decl of node.declarationList.declarations) {
+                    if (decl.name) {
+                        exports[decl.name.getText(source)] = { declaration: decl, source, name: decl.name.getText(source) };
+                    }
+                }
+            }
+        }
+        else if (ts.isExportDeclaration(node)) {
+            if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+                if (node.moduleSpecifier) {
+                    if (!ts.isStringLiteral(node.moduleSpecifier)) {
+                        continue;
+                    }
+                    // export { whatever } from 'whatever';
+                    const specifier = node.moduleSpecifier.text;
+                    const moduleExports = await findExports(await resolveModuleFn(specifier, new URL(source.fileName)), resolveModuleFn);
+                    for (const name of Array.from(node.exportClause.elements, (e) => e.name.getText(source))) {
+                        if (!(name in moduleExports)) {
+                            throw new Error(`Exported name ${name} not found in ${JSON.stringify(specifier)}`);
+                        }
+                        exports[name] = moduleExports[name];
+                    }
+                }
+                else {
+                    for (const element of node.exportClause.elements) {
+                        namedExports.push({
+                            name: element.name.text,
+                            property: element.propertyName?.text,
+                        });
+                        // exports[element.name.getText(source)] = { declaration: element, source };
+                    }
+                }
+            }
+            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));
+            }
+        }
+    }
+    if (namedExports.length) {
+        const names = Object.fromEntries(namedExports.map((e) => [e.property ?? e.name, e.name]));
+        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) {
+                        exports[names[decl.name.getText(source)]] = {
+                            declaration: decl,
+                            source,
+                            name: names[decl.name.getText(source)],
+                        };
+                    }
+                }
+            }
+            if (ts.isFunctionDeclaration(statement)) {
+                if (statement.name && ts.isIdentifier(statement.name) && statement.name.getText(source) in names) {
+                    exports[names[statement.name.getText(source)]] = {
+                        declaration: statement,
+                        source,
+                        name: names[statement.name.getText(source)],
+                    };
+                }
+            }
+            if (ts.isClassDeclaration(statement)) {
+                if (statement.name && ts.isIdentifier(statement.name) && statement.name.getText(source) in names) {
+                    exports[names[statement.name.getText(source)]] = {
+                        declaration: statement,
+                        source,
+                        name: names[statement.name.getText(source)],
+                    };
+                }
+            }
+            if (ts.isTypeAliasDeclaration(statement)) {
+                if (statement.name && ts.isIdentifier(statement.name) && statement.name.getText(source) in names) {
+                    exports[names[statement.name.getText(source)]] = {
+                        declaration: statement,
+                        source,
+                        name: names[statement.name.getText(source)],
+                    };
+                }
+            }
+            if (ts.isInterfaceDeclaration(statement)) {
+                if (statement.name && ts.isIdentifier(statement.name) && statement.name.getText(source) in names) {
+                    exports[names[statement.name.getText(source)]] = {
+                        declaration: statement,
+                        source,
+                        name: names[statement.name.getText(source)],
+                    };
+                }
+            }
+            if (ts.isEnumDeclaration(statement)) {
+                if (statement.name && ts.isIdentifier(statement.name) && statement.name.getText(source) in names) {
+                    exports[names[statement.name.getText(source)]] = {
+                        declaration: statement,
+                        source,
+                        name: names[statement.name.getText(source)],
+                    };
+                }
+            }
+            if (ts.isImportDeclaration(statement)) {
+                if (statement.importClause && 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) &&
+                            element.propertyName.getText(source) in names) {
+                            if (!importExports && ts.isStringLiteral(statement.moduleSpecifier)) {
+                                const specifier = statement.moduleSpecifier.getText(source);
+                                importExports = await findExports(await resolveModuleFn(specifier, new URL(source.fileName)), resolveModuleFn);
+                            }
+                            if (!importExports) {
+                                throw new Error(`Unable to find exports for ${statement.moduleSpecifier.getText(source)}`);
+                            }
+                            if (!importExports[element.name.getText(source)]) {
+                                throw new Error(`Exported name ${element.name.getText(source)} not found in ${JSON.stringify(statement.moduleSpecifier.getText(source))}`);
+                            }
+                            exports[names[element.propertyName.getText(source)]] = {
+                                declaration: element,
+                                source,
+                                name: names[element.propertyName.getText(source)],
+                            };
+                        }
+                    }
+                }
+            }
+        }
+    }
+    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;
+    return {
+        path: url$1,
+        exports: await findExports(source),
+        source,
+    };
+}
+/**
+ * NOTE: this is an internal value in the TypeScript compiler
+ *
+ * @see https://github.com/microsoft/TypeScript/blob/0d0a79371471d627ae298a145f8009b05cbccb72/src/compiler/scanner.ts#L81
+ */
+const keywords = new Set(Object.keys(ts.textToKeywordObj));
+
+class RequiredPackages {
+    requires;
+    // map from symbol to module path
+    symbols = {};
+    aliases = {};
+    constructor(requires = {}) {
+        this.requires = requires;
+        for (const [pkg, symbols] of Object.entries(requires)) {
+            for (const symbol of symbols) {
+                this.symbols[symbol] = pkg;
+            }
+        }
+    }
+    addRequires(pkg, name, alias) {
+        if (!(pkg in this.requires)) {
+            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++)
+                ;
+        }
+        this.requires[pkg].add(symbol);
+        this.symbols[symbol] = pkg;
+        if (symbol !== name) {
+            this.aliases[symbol] = name;
+        }
+        return symbol;
+    }
+}
+
+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));
+    return ref.property ? ns.dot(ref.property) : ns;
+}
+
+function compareEntryKey([a], [b]) {
+    return a.localeCompare(b);
+}
+function compareName({ name: a }, { name: b }) {
+    return a.localeCompare(b);
+}
+function isPrimitiveType(type) {
+    switch (type.name) {
+        case "ID":
+        case "Int":
+        case "Float":
+        case "String":
+        case "Boolean":
+            return true;
+    }
+    return false;
+}
+function importAlias(line) {
+    const pos = line.indexOf(" as ");
+    if (pos === -1) {
+        return "";
+    }
+    return line.slice(pos + 4);
+}
+function renderImports(base, imports, aliases, extMode = "omit") {
+    return jen.statements(...imports.map(([pkg, symbols]) => {
+        let mod = pkg;
+        if (mod.startsWith("file:///")) {
+            mod = url.fileURLToPath(mod);
+        }
+        if (mod.startsWith('/')) {
+            mod = path.relative(base, mod);
+            if (!mod.startsWith(".")) {
+                mod = `./${mod}`;
+            }
+        }
+        if (extMode === "omit") {
+            const ext = path.extname(mod);
+            if (ext) {
+                mod = mod.slice(0, -ext.length);
+            }
+        }
+        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);
+    }));
+}
+function isBuiltInDirective(name) {
+    // https://spec.graphql.org/draft/#sec-Type-System.Directives.Built-in-Directives
+    switch (name) {
+        case "deprecated":
+        case "skip":
+        case "include":
+        case "specifiedBy":
+            return true;
+    }
+    return false;
+}
+function truthify(arr) {
+    return arr.filter(Boolean);
+}
+class GeneratorContext {
+    _pkgs;
+    _extMode;
+    _scalarsInfo;
+    _fieldDirectivesInfo;
+    _inputDirectivesInfo;
+    _resolversInfo;
+    _subscribersInfo;
+    _graphqlModuleSpecifier;
+    constructor(options = {}) {
+        this._scalarsInfo = options.scalarsInfo ?? {};
+        this._fieldDirectivesInfo = options.fieldDirectivesInfo ?? {};
+        this._inputDirectivesInfo = options.inputDirectivesInfo ?? {};
+        this._resolversInfo = options.resolversInfo ?? {};
+        this._subscribersInfo = options.subscribersInfo ?? {};
+        this._graphqlModuleSpecifier = options.graphqlModuleSpecifier ?? "graphql";
+        this._pkgs = new RequiredPackages();
+        this._extMode = options.extMode ?? "omit";
+    }
+    _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));
+        }
+        if (type instanceof graphql.GraphQLList) {
+            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 jen.id(type.name + "Scalar");
+        }
+        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)
+            .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)),
+        ])))));
+    }
+    _renderValueNode(node) {
+        switch (node.kind) {
+            case graphql.Kind.ENUM:
+            case graphql.Kind.STRING:
+            case graphql.Kind.BOOLEAN:
+                return jen.lit(node.value);
+            case graphql.Kind.INT:
+            case graphql.Kind.FLOAT:
+                return jen.id(node.value);
+            case graphql.Kind.NULL:
+                return jen.null;
+            case graphql.Kind.LIST:
+                return jen.array(...node.values.map((v) => this._renderValueNode(v)));
+            case graphql.Kind.OBJECT:
+                return jen.obj(...node.fields.map((f) => jen.prop(f.name.value, this._renderValueNode(f.value))));
+        }
+        throw new Error(`unexpected value kind: ${node.kind}`);
+    }
+    _renderArgumentNodes(nodes) {
+        return jen.obj(...Array.from(nodes ?? [], (arg) => jen.prop(arg.name.value, this._renderValueNode(arg.value))));
+    }
+    _renderFieldObject(type, f, inputFieldDirectives) {
+        let resolver = this._resolversInfo[type.name]?.[f.name];
+        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])) {
+                    break;
+                }
+            }
+        }
+        let resolveFn = resolver && renderSymbolReference(this._pkgs, resolver);
+        if (f.astNode?.directives?.length) {
+            // apply directives in reverse order
+            for (const directive of Array.from(f.astNode.directives).reverse()) {
+                const ref = this._fieldDirectivesInfo[directive.name.value];
+                if (!ref) {
+                    continue;
+                }
+                if (!resolveFn) {
+                    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)] : []));
+            }
+        }
+        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(":")
+                    .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);
+            }
+        }
+        // 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 
+        //       `Subscription`.
+        //
+        //       In theory, an alternate implementation could be created to call `subscribe` at every level, but considering
+        //       how subscribe functions work, it would be unclear how it would make sense.
+        //
+        //       If you ever need such functionality, please open an issue and it can be discussed.
+        //
+        //       @see https://github.com/graphql/graphql-js/blob/e9a81f2ba9020ec5fd0f67f5553ccabe392e95e8/src/execution/execute.ts#L1645
+        const subscriber = type.name === "Subscription" ? this._subscribersInfo[f.name] : undefined;
+        return jen.obj(jen.prop("type", this._renderGraphQLTypeIdentifier(f.type)), ...truthify([
+            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)),
+            // 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", renderSymbolReference(this._pkgs, subscriber)),
+        ]));
+    }
+    _renderFieldsThunk(type, inputFieldDirectives) {
+        return jen.arrow().parens(jen.obj(...Object.values(type.getFields())
+            .sort(compareName)
+            .map((field) => jen.prop(field.name, this._renderFieldObject(type, field, inputFieldDirectives)))));
+    }
+    _renderOptionalGraphQLTypeType(type) {
+        if (type instanceof graphql.GraphQLNonNull) {
+            return this._renderGraphQLTypeType(type);
+        }
+        return jen.union(this._renderGraphQLTypeType(type), jen.undefined);
+    }
+    _deriveGraphQLTypeName(type) {
+        if (type instanceof graphql.GraphQLScalarType) {
+            const scalarType = this._findScalarType(type);
+            if (scalarType) {
+                return scalarType;
+            }
+            return "unknown";
+        }
+        if (type instanceof graphql.GraphQLEnumType) {
+            return "E" + type.name;
+        }
+        return type.name;
+    }
+    _scalarTypeTypeCache = {};
+    _findScalarType(type) {
+        if (type.name in this._scalarTypeTypeCache) {
+            return this._scalarTypeTypeCache[type.name];
+        }
+        let returnType;
+        const info = this._scalarsInfo[type.name];
+        if (info?.type) {
+            if (info.type.module) {
+                returnType = this._pkgs.addRequires(info.type.module, info.type.symbol);
+            }
+            returnType = info.type.symbol;
+        }
+        if (!returnType) {
+            // these are the built-in scalars
+            switch (type.name) {
+                case "ID":
+                    returnType = "string | number";
+                    break;
+                case "Int":
+                case "Float":
+                    returnType = "number";
+                    break;
+                case "String":
+                    returnType = "string";
+                    break;
+                case "Boolean":
+                    returnType = "boolean";
+                    break;
+            }
+        }
+        if (!returnType) {
+            console.log("WARNING: Could not determine scalar " + type.name + " type from parseValue or parseLiteral");
+        }
+        return (this._scalarTypeTypeCache[type.name] = 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));
+        }
+        if (type instanceof graphql.GraphQLDirective) {
+            throw new Error("unexpected directive type " + type.name);
+        }
+        return jen.id(this._deriveGraphQLTypeName(type));
+    }
+    _renderTypeInterface(type) {
+        return jen.interface.add(this._renderGraphQLTypeType(type)).block(...Object.values(type.getFields())
+            .sort(compareName)
+            .map((field) => jen.prop(jen.id(field.name).op("?"), this._renderGraphQLTypeType(field.type))));
+    }
+    _renderGraphQLObjectTypeDefinition(type, { inputFieldDirectives }) {
+        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)), ...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))),
+        ]))).as.add(this._gql("GraphQLObjectType"));
+    }
+    _renderGraphQLObjectTypeTypes(type) {
+        const fieldsWithArgs = Object.values(type.getFields())
+            .filter((field) => field.args.length)
+            .sort(compareName);
+        return [
+            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)
+                        .sort(compareName)
+                        .map((arg) => jen.prop(arg.name, this._renderOptionalGraphQLTypeType(arg.type)))))),
+                ]
+                : []),
+        ];
+    }
+    _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)),
+        ])));
+    }
+    _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.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, { implementors: { implementors }, inputFieldDirectives }) {
+        return jen.new.add(this._gql("GraphQLInterfaceType")).call(jen.obj(jen.prop("name", jen.lit(type.name)), jen.prop("fields", this._renderFieldsThunk(type, inputFieldDirectives)), ...truthify([
+            type.description && jen.prop("description", jen.lit(type.description)),
+        ]))).as.add(this._gql("GraphQLInterfaceType"));
+    }
+    _renderGraphQLInterfaceTypeTypes(type, { implementors: { implementors } }) {
+        const fieldsWithArgs = Object.values(type.getFields())
+            .filter((field) => field.args.length)
+            .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)
+                .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)),
+        ])));
+    }
+    _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)))),
+        ];
+    }
+    _findInputDirectiveInfoFromArgOrField(field, inputFieldDirectives) {
+        const fieldTypeName = graphql.getNamedType(field.type).name;
+        let transform;
+        if (inputFieldDirectives[fieldTypeName] && Object.keys(inputFieldDirectives[fieldTypeName]).length) {
+            transform = {
+                symbol: "transform" + fieldTypeName,
+            };
+        }
+        if (field.astNode?.directives?.length) {
+            const directives = field.astNode.directives.flatMap((directive) => {
+                const ref = this._inputDirectivesInfo[directive.name.value];
+                if (!ref) {
+                    return [];
+                }
+                return [{ ref, args: directive.arguments }];
+            });
+            if (directives.length) {
+                return { field, directives, transform };
+            }
+        }
+        if (transform) {
+            return { field, directives: [], transform };
+        }
+    }
+    _renderInputFieldsWithDirectives(valueExpr, fieldsWithDirectives, spread) {
+        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;
+            if (nullableType instanceof graphql.GraphQLList) {
+                transformedExpr = jen.id("elem");
+            }
+            else {
+                transformedExpr = fieldExpr;
+            }
+            if (transform) {
+                transformedExpr = renderSymbolReference(this._pkgs, transform).call(transformedExpr);
+            }
+            for (const { ref, args } of directives) {
+                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));
+                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);
+                }
+            }
+            return jen.prop(field.name, transformedExpr);
+        }));
+    }
+    _renderGraphQLInputObjectTypeDefinition(type, { inputFieldDirectives }) {
+        return jen.new.add(this._gql("GraphQLInputObjectType")).call(jen.obj(jen.prop("name", jen.lit(type.name)), jen.prop("fields", this._renderFieldsThunk(type, inputFieldDirectives)), ...truthify([
+            type.description && jen.prop("description", jen.lit(type.description)),
+        ])));
+    }
+    _renderGraphQLInputObjectTypeTypes(type, { 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))),
+            ]),
+        ];
+    }
+    _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)),
+        ])))))), ...truthify([
+            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)))),
+        ];
+    }
+    _getRenderDefintionFnForType(type) {
+        if (type instanceof graphql.GraphQLObjectType) {
+            return this._renderGraphQLObjectTypeDefinition.bind(this, type);
+        }
+        if (type instanceof graphql.GraphQLScalarType) {
+            return this._renderGraphQLScalarTypeDefinition.bind(this, type);
+        }
+        if (type instanceof graphql.GraphQLInterfaceType) {
+            return this._renderGraphQLInterfaceTypeDefinition.bind(this, type);
+        }
+        if (type instanceof graphql.GraphQLUnionType) {
+            return this._renderGraphQLUnionTypeDefinition.bind(this, type);
+        }
+        if (type instanceof graphql.GraphQLInputObjectType) {
+            return this._renderGraphQLInputObjectTypeDefinition.bind(this, type);
+        }
+        if (type instanceof graphql.GraphQLEnumType) {
+            return this._renderGraphQLEnumTypeDefinition.bind(this, type);
+        }
+        throw new Error("unhandled type: " + type.toString());
+    }
+    _getRenderTypesFnForType(type) {
+        if (type instanceof graphql.GraphQLObjectType) {
+            return this._renderGraphQLObjectTypeTypes.bind(this, type);
+        }
+        if (type instanceof graphql.GraphQLScalarType) {
+            return () => [];
+        }
+        if (type instanceof graphql.GraphQLInterfaceType) {
+            return this._renderGraphQLInterfaceTypeTypes.bind(this, type);
+        }
+        if (type instanceof graphql.GraphQLUnionType) {
+            return this._renderGraphQLUnionTypeTypes.bind(this, type);
+        }
+        if (type instanceof graphql.GraphQLInputObjectType) {
+            return this._renderGraphQLInputObjectTypeTypes.bind(this, type);
+        }
+        if (type instanceof graphql.GraphQLEnumType) {
+            return this._renderGraphQLEnumTypeTypes.bind(this, type);
+        }
+        throw new Error("unhandled type: " + type.toString());
+    }
+    _renderGraphQLTypeDefinitions(type, interfaces, inputFieldDirectives) {
+        return jen.const.add(this._renderGraphQLTypeIdentifier(type)).op("=").add(this._getRenderDefintionFnForType(type)({
+            implementors: interfaces[type.name],
+            inputFieldDirectives,
+        }));
+    }
+    _renderGraphQLTypeTypes(type, interfaces, inputFieldDirectives) {
+        return this._getRenderTypesFnForType(type)({
+            implementors: interfaces[type.name],
+            inputFieldDirectives,
+        });
+    }
+    _renderGraphQLDirectiveDefinition(directive) {
+        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),
+        ])));
+    }
+    _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)))),
+        ]);
+    }
+    schemaExprs(schema, [types, interfaces, inputFieldDirectives]) {
+        return [
+            ...[
+                // render type definitions
+                ...types
+                    .map((type) => [type.name, this._renderGraphQLTypeDefinitions(type, interfaces, inputFieldDirectives)])
+                    .sort(compareEntryKey),
+                // render directive definitions
+                ...schema.getDirectives()
+                    .filter((d) => !isBuiltInDirective(d.name))
+                    .map((directive) => [directive.name, this._renderGraphQLDirectiveDefinition(directive)])
+                    .sort(compareEntryKey),
+            ].map(([, expr]) => expr),
+            // 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.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)))))),
+            jen.export.default.id("schema"),
+        ];
+    }
+    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"))))))],
+            // render type definitions
+            ...types
+                .map((type) => [type.name, jen.statements(...this._renderGraphQLTypeTypes(type, interfaces, inputFieldDirectives))])
+                .sort(compareEntryKey),
+            // render directive definitions
+            ...schema.getDirectives()
+                .filter((d) => !isBuiltInDirective(d.name))
+                .map((directive) => [directive.name, jen.statements(...this._renderGraphQLDirectiveTypes(directive))])
+                .sort(compareEntryKey),
+        ].map(([, expr]) => expr);
+    }
+    schemaAndTypesExprs(schema, [types, interfaces, inputFieldDirectives]) {
+        return [
+            ...this.schemaExprs(schema, [types, interfaces, inputFieldDirectives]),
+            ...this.typesExprs(schema, [types, interfaces, inputFieldDirectives]),
+        ];
+    }
+    renderFile(outfile, renderStatements) {
+        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());
+    }
+    static prepareInterfacesAndInputFieldDirectives(schema, options = {}) {
+        if (options.fieldDirectivesInfo) {
+            const names = new Set(Object.keys(options.fieldDirectivesInfo));
+            for (const directive of schema.getDirectives()) {
+                if (isBuiltInDirective(directive.name) ||
+                    directive.locations.every((loc) => loc !== graphql.DirectiveLocation.FIELD_DEFINITION) ||
+                    names.has(directive.name)) {
+                    continue;
+                }
+                console.log(`WARNING: missing directive function for ${JSON.stringify(directive.name)}`);
+            }
+        }
+        const types = Object.entries(schema.getTypeMap())
+            .sort(compareEntryKey)
+            .filter(([, type]) => !type.name.startsWith("__") && !isPrimitiveType(type))
+            .map(([, type]) => type);
+        const inputFieldDirectives = {};
+        if (options.inputDirectivesInfo) {
+            // input field directives not needed if the module was not specified
+            let typesWithObjectFields = new Array();
+            for (const type of types) {
+                if (!(type instanceof graphql.GraphQLInputObjectType)) {
+                    continue;
+                }
+                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]);
+                    }
+                    const directives = field.astNode?.directives;
+                    if (!directives) {
+                        continue;
+                    }
+                    for (const directive of directives) {
+                        const name = directive.name.value;
+                        if (!options.inputDirectivesInfo[name]) {
+                            continue;
+                        }
+                        const fieldDirectives = inputFieldDirectives[type.name] ?? (inputFieldDirectives[type.name] = {});
+                        const fieldDirective = fieldDirectives[field.name] ?? (fieldDirectives[field.name] = []);
+                        fieldDirective.push(name);
+                    }
+                }
+            }
+            for (let changes = 1; changes; changes = 0) {
+                const newTypesWithObjectFields = new Array();
+                for (const [typeName, fieldName, objectTypeName] of typesWithObjectFields) {
+                    console.log(`checking ${typeName}.${fieldName} for ${objectTypeName}`);
+                    if (inputFieldDirectives[objectTypeName]) {
+                        inputFieldDirectives[typeName] = { ...inputFieldDirectives[typeName], [fieldName]: [] };
+                        changes += 1;
+                    }
+                    else {
+                        newTypesWithObjectFields.push([typeName, fieldName, objectTypeName]);
+                    }
+                }
+                typesWithObjectFields = newTypesWithObjectFields;
+            }
+        }
+        const interfaces = {};
+        for (const type of types) {
+            if (!(type instanceof graphql.GraphQLObjectType)) {
+                continue;
+            }
+            for (const iface of type.getInterfaces()) {
+                if (!(iface.name in interfaces)) {
+                    interfaces[iface.name] = {
+                        interface: iface,
+                        implementors: [],
+                    };
+                }
+                interfaces[iface.name].implementors.push(type);
+            }
+        }
+        return [types, interfaces, inputFieldDirectives];
+    }
+}
+function createGenerator(schema, options) {
+    const args = GeneratorContext.prepareInterfacesAndInputFieldDirectives(schema, options);
+    return {
+        generateSchema: (outfile) => new GeneratorContext(options).renderFile(outfile, function () {
+            return this.schemaExprs(schema, args);
+        }),
+        generateTypes: (outfile) => new GeneratorContext(options).renderFile(outfile, function () {
+            return this.typesExprs(schema, args);
+        }),
+        generate: (outfile) => new GeneratorContext(options).renderFile(outfile, function () {
+            return this.schemaAndTypesExprs(schema, args);
+        }),
+    };
+}
+function generateSchema(schema, outfile, options = {}) {
+    return createGenerator(schema, options).generateSchema(outfile);
+}
+function generateTypes(schema, outfile, options = {}) {
+    return createGenerator(schema, options).generateTypes(outfile);
+}
+function generate(schema, outfile, options = {}) {
+    return createGenerator(schema, options).generate(outfile);
+}
+
+async function parseResolverFile(path) {
+    return Object.fromEntries(Object.entries((await parseModule(path)).exports)
+        .flatMap(([name, { declaration }]) => {
+        if (ts.isVariableDeclaration(declaration) && declaration.initializer) {
+            if (ts.isFunctionExpression(declaration.initializer)) {
+                return [[name, { module: path, symbol: name }]];
+            }
+            if (ts.isArrowFunction(declaration.initializer)) {
+                return [[name, { module: path, symbol: name }]];
+            }
+        }
+        if (ts.isFunctionDeclaration(declaration)) {
+            return [[name, { module: path, symbol: name }]];
+        }
+        return [];
+    }));
+}
+async function parseTypeResolvers(typeName, glob$1) {
+    const result = {};
+    for await (const entry of glob.globIterate(glob$1, { withFileTypes: true })) {
+        const fullpath = entry.fullpath();
+        if (entry.isFile() && entry.name.endsWith(".ts")) {
+            for (const [name, reference] of Object.entries(await parseResolverFile(fullpath))) {
+                let realName = name;
+                if (realName === "default") {
+                    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}`);
+                }
+                result[realName] = reference;
+            }
+        }
+    }
+    return result;
+}
+async function parse$2(dirpath) {
+    const dir = await fs.stat(dirpath);
+    if (!dir.isDirectory()) {
+        throw new Error(`Expected ${dirpath} to be a directory`);
+    }
+    if (!dirpath.endsWith("/")) {
+        dirpath += "/";
+    }
+    const out = {};
+    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");
+        }
+        else if (entry.isFile() && name.endsWith(".ts")) {
+            out[name.slice(0, -3)] = await parseTypeResolvers(name.slice(0, -3), file);
+        }
+    }
+    return out;
+}
+
+function locLineColumn$1(decl, source) {
+    const head = source.text.slice(0, decl.pos);
+    return [
+        head.split("\n").length,
+        head.slice(head.lastIndexOf("\n") + 1).length + 1,
+    ];
+}
+function refFromImportTypeNode(node, source) {
+    if (node.isTypeOf) {
+        console.log("WARNING: typeof namespace import for scalar type is not supported");
+        return;
+    }
+    if (!node.qualifier || !ts.isIdentifier(node.qualifier)) {
+        console.log("WARNING: namespace import for scalar type is not supported");
+        return;
+    }
+    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}`);
+        return;
+    }
+    return { module: node.argument.literal.text, symbol: node.qualifier.text };
+}
+function refFromTypeReferenceNode(typeNode, source) {
+    if (typeNode.typeName.kind === ts.SyntaxKind.QualifiedName) {
+        // TODO: handle qualified names
+        return;
+    }
+    const typeName = typeNode.typeName.text;
+    for (const statement of source.statements) {
+        if (ts.isImportDeclaration(statement)) {
+            // search imports
+            if (!ts.isStringLiteral(statement.moduleSpecifier)) {
+                // this is a grammar error, handling it is out of scope
+                continue;
+            }
+            if (!statement.importClause) {
+                // side-effect import
+                continue;
+            }
+            if (statement.importClause.name) {
+                // default import
+                if (statement.importClause.name.text === typeName) {
+                    return { module: statement.importClause.name.text, symbol: 'default', alias: typeName };
+                }
+            }
+            if (!statement.importClause.namedBindings) {
+                // this is a grammar error, handling it is out of scope
+                continue;
+            }
+            if (!ts.isNamedImports(statement.importClause.namedBindings)) {
+                // TODO: handle namespace imports (will need to check if `typeName` has a dot in it)
+                continue;
+            }
+            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 };
+                }
+            }
+        }
+        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`);
+                    continue;
+                }
+                return { module: source.fileName, symbol: typeName };
+            }
+        }
+    }
+    // assume intrinsic or global type
+    return { symbol: typeName };
+}
+function refFromTypeNode(typeNode, source) {
+    if (ts.isImportTypeNode(typeNode)) {
+        return refFromImportTypeNode(typeNode, source);
+    }
+    else if (ts.isTokenKind(typeNode.kind)) {
+        // primitive type string, number, etc...
+        return { symbol: typeNode.getText(source) };
+    }
+    else if (ts.isTypeReferenceNode(typeNode)) {
+        return refFromTypeReferenceNode(typeNode, source);
+    }
+    else {
+        console.warn("WARNING: unexpected type node: " + ts.SyntaxKind[typeNode.kind]);
+    }
+}
+function reconcileScalarType(scalarName, typeDecls, source) {
+    let type;
+    for (const typeNode of typeDecls) {
+        if (!typeNode) {
+            continue;
+        }
+        let newType = refFromTypeNode(typeNode, source);
+        if (type && newType) {
+            if (type.symbol !== newType.symbol ||
+                type.alias !== newType.alias ||
+                type.module !== newType.module ||
+                type.property !== newType.property) {
+                throw new Error(`mismatched types do not match for scalar ${scalarName}: ${type.symbol} !== ${newType.symbol}`);
+            }
+        }
+        else if (!type && newType) {
+            type = newType;
+        }
+    }
+    return type;
+}
+function scalarInfoFromObjectLiteralExpression(scalarName, module, properties) {
+    return Object.fromEntries(Array.from(properties).flatMap((prop) => {
+        if (ts.isPropertyAssignment(prop)) {
+            if (!ts.isIdentifier(prop.name)) {
+                return [];
+            }
+            switch (prop.name.text) {
+                case "serialize":
+                case "parseValue":
+                case "parseLiteral":
+                    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 [[
+                            `${prop.name.text}Func`,
+                            {
+                                module: module,
+                                symbol: scalarName,
+                                property: prop.name.text,
+                                declaration: prop.initializer,
+                            },
+                        ]];
+                default:
+                    console.log(`WARNING: found extraneous scalar property ${scalarName}.${prop.name.text}`);
+            }
+        }
+        else if (ts.isMethodDeclaration(prop)) {
+            if (!ts.isIdentifier(prop.name)) {
+                return [];
+            }
+            switch (prop.name.text) {
+                case "serialize":
+                case "parseValue":
+                case "parseLiteral":
+                    return [[
+                            `${prop.name.text}Func`,
+                            {
+                                module,
+                                symbol: scalarName,
+                                property: prop.name.text,
+                                declaration: prop,
+                            },
+                        ]];
+                default:
+                    console.log(`WARNING: found extraneous scalar property ${scalarName}.${prop.name.text}`);
+            }
+        }
+        else {
+            console.log(`WARNING: unsupported object literal element in scalar object ${scalarName}: ${ts.SyntaxKind[prop.kind]}`);
+        }
+        return [];
+    }));
+}
+async function parse$1(path) {
+    const scalarFnsInfos = {};
+    const scalarTypeNodes = {};
+    const sources = {};
+    for (const [name, { declaration, source }] of Object.entries((await parseModule(path)).exports)) {
+        sources[name] = source;
+        if (ts.isVariableDeclaration(declaration)) {
+            if (declaration.initializer && ts.isObjectLiteralExpression(declaration.initializer)) {
+                scalarFnsInfos[name] = scalarInfoFromObjectLiteralExpression(name, new URL(source.fileName).toString(), declaration.initializer.properties);
+            }
+        }
+        else if (ts.isTypeAliasDeclaration(declaration)) {
+            if (declaration.typeParameters?.length) {
+                console.log(`WARNING: skipping scalar type ${name}: type parameters are not supported`);
+                continue;
+            }
+            const ref = refFromTypeNode(declaration.type, source);
+            if (ref) {
+                scalarTypeNodes[name] = declaration.type;
+            }
+        }
+    }
+    const infos = {};
+    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, [
+            fnsInfo?.serializeFunc?.declaration?.parameters?.[0]?.type,
+            fnsInfo?.parseValueFunc?.declaration?.type,
+            fnsInfo?.parseLiteralFunc?.declaration?.type,
+        ], source);
+        if (type) {
+            if (type.module) {
+                type.module = new URL(type.module, source.fileName).toString();
+            }
+        }
+        infos[name] = {
+            ...fnsInfo,
+            type,
+        };
+    }
+    return infos;
+}
+
+function locLineColumn(loc) {
+    const head = loc.source.body.slice(0, loc.start);
+    return [
+        head.split("\n").length,
+        head.slice(head.lastIndexOf("\n") + 1).length + 1,
+    ];
+}
+function traceLine(loc, prefix = "") {
+    if (!loc) {
+        return "";
+    }
+    return `\n    ${prefix}at file://${loc.source.name}:${locLineColumn(loc).join(":")}`;
+}
+function setTraceToSchema(err, name, loc) {
+    if (globalThis.Deno) {
+        if (loc) {
+            const trace = err.__callSiteEvals;
+            const [lineNumber, columnNumber] = locLineColumn(loc);
+            // NOTE: this is deno magic
+            // @see https://github.com/denoland/deno/blob/b1b418b81a13ede548273665e83c1bc5a97dffcd/core/error.rs#L275
+            Object.defineProperty(err, "__callSiteEvals", {
+                get: () => [
+                    {
+                        this: undefined,
+                        typeName: null,
+                        function: undefined,
+                        functionName: name,
+                        methodName: null,
+                        fileName: "file://" + loc.source.name,
+                        lineNumber,
+                        columnNumber,
+                        evalOrigin: undefined,
+                        isToplevel: true,
+                        isEval: false,
+                        isNative: false,
+                        isConstructor: false,
+                        isAsync: false,
+                        isPromiseAll: false,
+                        promiseIndex: null,
+                    },
+                    ...trace,
+                ],
+            });
+        }
+    }
+    return err;
+}
+function namedNodesDict(nodes = []) {
+    return Object.fromEntries(nodes.map((node) => [node.name.value, node]));
+}
+function sortNamedNodes(nodes) {
+    return Array.from(nodes).sort(({ name: { value: a } }, { name: { value: b } }) => a.localeCompare(b));
+}
+function isIntValueNodeEqual(a, b) {
+    return a.value === b.value;
+}
+function isFloatValueNodeEqual(a, b) {
+    return a.value === b.value;
+}
+function isStringValueNodeEqual(a, b) {
+    return a.value === b.value;
+}
+function isBooleanValueNodeEqual(a, b) {
+    return a.value === b.value;
+}
+function isEnumValueNodeEqual(a, b) {
+    return a.value === b.value;
+}
+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));
+}
+function isValueNodeEqual(a, b) {
+    if (a === b || (!a && !b)) {
+        return true;
+    }
+    if (!a || !b || a.kind !== b.kind) {
+        return false;
+    }
+    switch (a.kind) {
+        case graphql.Kind.INT:
+            return isIntValueNodeEqual(a, b);
+        case graphql.Kind.FLOAT:
+            return isFloatValueNodeEqual(a, b);
+        case graphql.Kind.STRING:
+            return isStringValueNodeEqual(a, b);
+        case graphql.Kind.BOOLEAN:
+            return isBooleanValueNodeEqual(a, b);
+        case graphql.Kind.ENUM:
+            return isEnumValueNodeEqual(a, b);
+        case graphql.Kind.LIST:
+            return isListValueNodeEqual(a, b);
+        case graphql.Kind.OBJECT:
+            return isObjectValueNodeEqual(a, b);
+        case graphql.Kind.NULL:
+        case graphql.Kind.VARIABLE:
+            return true;
+    }
+}
+function isArgumentNodesEqual(a, b) {
+    if (a === b || (!a && !b)) {
+        return true;
+    }
+    if (!a || !b || a.length !== b.length) {
+        return false;
+    }
+    return zip(sortNamedNodes(a), sortNamedNodes(b)).every(([a, b]) => a.name.value === b.name.value && isValueNodeEqual(a.value, b.value));
+}
+function isTypeNodeEqual(a, b) {
+    if (a.kind !== b.kind) {
+        return false;
+    }
+    switch (a.kind) {
+        case graphql.Kind.NAMED_TYPE:
+            return a.name.value === b.name.value;
+        case graphql.Kind.LIST_TYPE:
+            return isTypeNodeEqual(a.type, b.type);
+        case graphql.Kind.NON_NULL_TYPE:
+            return isTypeNodeEqual(a.type, b.type);
+    }
+}
+function isDirectiveNodesEqual(a, b) {
+    if (a === b || (!a && !b)) {
+        return true;
+    }
+    if (!a || !b || a.length !== b.length) {
+        return false;
+    }
+    return zip(sortNamedNodes(a), sortNamedNodes(b)).every(([a, b]) => a.name.value === b.name.value &&
+        isArgumentNodesEqual(a.arguments, b.arguments));
+}
+function isInputValueDefinitionNodesEqual(a, b) {
+    if (a === b || (!a && !b)) {
+        return true;
+    }
+    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) &&
+        isValueNodeEqual(a.defaultValue, b.defaultValue) &&
+        isDirectiveNodesEqual(a.directives, b.directives));
+}
+function mergeFieldDefinitionNodes(name, a, b) {
+    const fields = namedNodesDict(a);
+    if (b) {
+        for (const f of 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);
+                }
+                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);
+                }
+                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),
+                };
+            }
+            else {
+                fields[f.name.value] = f;
+            }
+        }
+    }
+    return Object.values(fields);
+}
+function mergeInputValueDefinitionNodes(name, a, b) {
+    const fields = namedNodesDict(a);
+    if (b) {
+        for (const f of 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);
+                }
+                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);
+                }
+                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),
+                };
+            }
+            else {
+                fields[f.name.value] = f;
+            }
+        }
+    }
+    return Object.values(fields);
+}
+function mergeNamedNodes(a, b) {
+    const nodes = namedNodesDict(a);
+    if (b) {
+        for (const n of b) {
+            nodes[n.name.value] = n;
+        }
+    }
+    return Object.values(nodes);
+}
+function mergeDirectiveNodes(name, a, b) {
+    const directives = namedNodesDict(a);
+    if (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);
+            }
+            directives[d.name.value] = d;
+        }
+    }
+    return Object.values(directives);
+}
+function mergeScalarTypeDefinitionNodes(a, b) {
+    if (a.name.value !== b.name.value) {
+        throw setTraceToSchema(new graphql.GraphQLError(`Cannot merge scalar types with different names: ${a.name.value} and ${b.name.value}`), a.name.value, a.loc);
+    }
+    return {
+        kind: graphql.Kind.SCALAR_TYPE_DEFINITION,
+        name: a.name,
+        directives: mergeDirectiveNodes(a.name.value, a.directives, b.directives),
+    };
+}
+function mergeObjectTypeDefinitionNodes(a, b) {
+    return {
+        kind: graphql.Kind.OBJECT_TYPE_DEFINITION,
+        loc: a.loc,
+        name: a.name,
+        description: a.description || b.description,
+        interfaces: mergeNamedNodes(a.interfaces, b.interfaces),
+        directives: mergeDirectiveNodes(a.name.value, a.directives, b.directives),
+        fields: mergeFieldDefinitionNodes(a.name.value, a.fields, b.fields),
+    };
+}
+function mergeInterfaceTypeDefinitionNodes(a, b) {
+    return {
+        kind: graphql.Kind.INTERFACE_TYPE_DEFINITION,
+        loc: a.loc,
+        name: a.name,
+        description: a.description || b.description,
+        interfaces: mergeNamedNodes(a.interfaces, b.interfaces),
+        directives: mergeDirectiveNodes(a.name.value, a.directives, b.directives),
+        fields: mergeFieldDefinitionNodes(a.name.value, a.fields, b.fields),
+    };
+}
+function mergeUnionTypeDefinitionNodes(a, b) {
+    return {
+        kind: graphql.Kind.UNION_TYPE_DEFINITION,
+        loc: a.loc,
+        name: a.name,
+        description: a.description || b.description,
+        directives: mergeDirectiveNodes(a.name.value, a.directives, b.directives),
+        types: mergeNamedNodes(a.types, b.types),
+    };
+}
+function mergeEnumTypeDefinitionNodes(a, b) {
+    const values = namedNodesDict(a.values);
+    if (b) {
+        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);
+            }
+            values[v.name.value] = v;
+        }
+    }
+    return {
+        kind: graphql.Kind.ENUM_TYPE_DEFINITION,
+        loc: a.loc,
+        name: a.name,
+        description: a.description || b.description,
+        directives: mergeDirectiveNodes(a.name.value, a.directives, b.directives),
+        values: Object.values(values),
+    };
+}
+function mergeInputObjectTypeDefinitionNodes(a, b) {
+    return {
+        kind: graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+        loc: a.loc,
+        name: a.name,
+        description: a.description || b.description,
+        directives: mergeDirectiveNodes(a.name.value, a.directives, b.directives),
+        fields: mergeInputValueDefinitionNodes(a.name.value, a.fields, b.fields),
+    };
+}
+function mergeDocumentNodes(documentNodes) {
+    const definitions = {};
+    for (const documentNode of documentNodes) {
+        for (const definition of documentNode.definitions) {
+            switch (definition.kind) {
+                case graphql.Kind.SCHEMA_DEFINITION:
+                case graphql.Kind.SCHEMA_EXTENSION:
+                case graphql.Kind.OPERATION_DEFINITION:
+                case graphql.Kind.FRAGMENT_DEFINITION:
+                case graphql.Kind.SCALAR_TYPE_EXTENSION:
+                case graphql.Kind.OBJECT_TYPE_EXTENSION:
+                case graphql.Kind.INTERFACE_TYPE_EXTENSION:
+                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);
+            }
+            const prevDefinition = definitions[definition.name.value];
+            if (!prevDefinition) {
+                definitions[definition.name.value] = definition;
+                continue;
+            }
+            if (prevDefinition.kind !== definition.kind) {
+                throw setTraceToSchema(new graphql.GraphQLError(`Cannot merge different definition kinds: ${prevDefinition.kind} and ${definition.kind}`), definition.name.value, definition.loc);
+            }
+            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 &&
+                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");
+            }
+            switch (definition.kind) {
+                case graphql.Kind.SCALAR_TYPE_DEFINITION:
+                    definitions[definition.name.value] = mergeScalarTypeDefinitionNodes(prevDefinition, definition);
+                    break;
+                case graphql.Kind.OBJECT_TYPE_DEFINITION:
+                    definitions[definition.name.value] = mergeObjectTypeDefinitionNodes(prevDefinition, definition);
+                    break;
+                case graphql.Kind.INTERFACE_TYPE_DEFINITION:
+                    definitions[definition.name.value] = mergeInterfaceTypeDefinitionNodes(prevDefinition, definition);
+                    break;
+                case graphql.Kind.UNION_TYPE_DEFINITION:
+                    definitions[definition.name.value] = mergeUnionTypeDefinitionNodes(prevDefinition, definition);
+                    break;
+                case graphql.Kind.ENUM_TYPE_DEFINITION:
+                    definitions[definition.name.value] = mergeEnumTypeDefinitionNodes(prevDefinition, definition);
+                    break;
+                case graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                    definitions[definition.name.value] = mergeInputObjectTypeDefinitionNodes(prevDefinition, definition);
+                    break;
+            }
+        }
+    }
+    return {
+        kind: graphql.Kind.DOCUMENT,
+        loc: documentNodes[0].loc,
+        definitions: Object.values(definitions),
+    };
+}
+
+async function* findSchemaFiles(glob$1) {
+    for await (const path$1 of glob.globIterate(glob$1)) {
+        const entry = await fs.stat(path$1);
+        if (entry.isFile()) {
+            yield path$1;
+        }
+        else if (entry.isDirectory()) {
+            yield* findSchemaFiles(path.join(path$1, "**/*.graphql"));
+        }
+    }
+}
+async function parse(glob) {
+    const documentNodes = [];
+    for await (const entry of findSchemaFiles(glob)) {
+        documentNodes.push(graphql.parse(new graphql.Source(await fs.readFile(entry, "utf-8"), entry)));
+    }
+    if (!documentNodes.length) {
+        throw new Error("No graphql files found");
+    }
+    const schema = graphql.buildASTSchema(mergeDocumentNodes(documentNodes));
+    const validationErrors = graphql.validateSchema(schema);
+    if (validationErrors.length > 0) {
+        throw validationErrors;
+    }
+    return schema;
+}
+
+exports.createGenerator = createGenerator;
+exports.generate = generate;
+exports.generateSchema = generateSchema;
+exports.generateTypes = generateTypes;
+exports.parseResolvers = parse$2;
+exports.parseScalars = parse$1;
+exports.parseSchema = parse;
+exports.parseTypeResolvers = parseTypeResolvers;