@graphql-tools/utils 8.7.0 → 8.8.0-alpha-b76ec274.0

package/esm/comments.js

@@ -0,0 +1,367 @@
+import { visit, TokenKind, } from 'graphql';
+const MAX_LINE_LENGTH = 80;
+let commentsRegistry = {};
+export function resetComments() {
+    commentsRegistry = {};
+}
+export function collectComment(node) {
+    var _a;
+    const entityName = (_a = node.name) === null || _a === void 0 ? void 0 : _a.value;
+    if (entityName == null) {
+        return;
+    }
+    pushComment(node, entityName);
+    switch (node.kind) {
+        case 'EnumTypeDefinition':
+            if (node.values) {
+                for (const value of node.values) {
+                    pushComment(value, entityName, value.name.value);
+                }
+            }
+            break;
+        case 'ObjectTypeDefinition':
+        case 'InputObjectTypeDefinition':
+        case 'InterfaceTypeDefinition':
+            if (node.fields) {
+                for (const field of node.fields) {
+                    pushComment(field, entityName, field.name.value);
+                    if (isFieldDefinitionNode(field) && field.arguments) {
+                        for (const arg of field.arguments) {
+                            pushComment(arg, entityName, field.name.value, arg.name.value);
+                        }
+                    }
+                }
+            }
+            break;
+    }
+}
+export function pushComment(node, entity, field, argument) {
+    const comment = getComment(node);
+    if (typeof comment !== 'string' || comment.length === 0) {
+        return;
+    }
+    const keys = [entity];
+    if (field) {
+        keys.push(field);
+        if (argument) {
+            keys.push(argument);
+        }
+    }
+    const path = keys.join('.');
+    if (!commentsRegistry[path]) {
+        commentsRegistry[path] = [];
+    }
+    commentsRegistry[path].push(comment);
+}
+export function printComment(comment) {
+    return '\n# ' + comment.replace(/\n/g, '\n# ');
+}
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * NOTE: ==> This file has been modified just to add comments to the printed AST
+ * This is a temp measure, we will move to using the original non modified printer.js ASAP.
+ */
+/**
+ * Given maybeArray, print an empty string if it is null or empty, otherwise
+ * print all items together separated by separator if provided
+ */
+function join(maybeArray, separator) {
+    return maybeArray ? maybeArray.filter(x => x).join(separator || '') : '';
+}
+function hasMultilineItems(maybeArray) {
+    var _a;
+    return (_a = maybeArray === null || maybeArray === void 0 ? void 0 : maybeArray.some(str => str.includes('\n'))) !== null && _a !== void 0 ? _a : false;
+}
+function addDescription(cb) {
+    return (node, _key, _parent, path, ancestors) => {
+        var _a;
+        const keys = [];
+        const parent = path.reduce((prev, key) => {
+            if (['fields', 'arguments', 'values'].includes(key) && prev.name) {
+                keys.push(prev.name.value);
+            }
+            return prev[key];
+        }, ancestors[0]);
+        const key = [...keys, (_a = parent === null || parent === void 0 ? void 0 : parent.name) === null || _a === void 0 ? void 0 : _a.value].filter(Boolean).join('.');
+        const items = [];
+        if (node.kind.includes('Definition') && commentsRegistry[key]) {
+            items.push(...commentsRegistry[key]);
+        }
+        return join([...items.map(printComment), node.description, cb(node, _key, _parent, path, ancestors)], '\n');
+    };
+}
+function indent(maybeString) {
+    return maybeString && `  ${maybeString.replace(/\n/g, '\n  ')}`;
+}
+/**
+ * Given array, print each item on its own line, wrapped in an
+ * indented "{ }" block.
+ */
+function block(array) {
+    return array && array.length !== 0 ? `{\n${indent(join(array, '\n'))}\n}` : '';
+}
+/**
+ * If maybeString is not null or empty, then wrap with start and end, otherwise
+ * print an empty string.
+ */
+function wrap(start, maybeString, end) {
+    return maybeString ? start + maybeString + (end || '') : '';
+}
+/**
+ * Print a block string in the indented block form by adding a leading and
+ * trailing blank line. However, if a block string starts with whitespace and is
+ * a single-line, adding a leading blank line would strip that whitespace.
+ */
+function printBlockString(value, isDescription = false) {
+    const escaped = value.replace(/"""/g, '\\"""');
+    return (value[0] === ' ' || value[0] === '\t') && value.indexOf('\n') === -1
+        ? `"""${escaped.replace(/"$/, '"\n')}"""`
+        : `"""\n${isDescription ? escaped : indent(escaped)}\n"""`;
+}
+const printDocASTReducer = {
+    Name: { leave: node => node.value },
+    Variable: { leave: node => '$' + node.name },
+    // Document
+    Document: {
+        leave: node => join(node.definitions, '\n\n'),
+    },
+    OperationDefinition: {
+        leave: node => {
+            const varDefs = wrap('(', join(node.variableDefinitions, ', '), ')');
+            const prefix = join([node.operation, join([node.name, varDefs]), join(node.directives, ' ')], ' ');
+            // the query short form.
+            return prefix + ' ' + node.selectionSet;
+        },
+    },
+    VariableDefinition: {
+        leave: ({ variable, type, defaultValue, directives }) => variable + ': ' + type + wrap(' = ', defaultValue) + wrap(' ', join(directives, ' ')),
+    },
+    SelectionSet: { leave: ({ selections }) => block(selections) },
+    Field: {
+        leave({ alias, name, arguments: args, directives, selectionSet }) {
+            const prefix = wrap('', alias, ': ') + name;
+            let argsLine = prefix + wrap('(', join(args, ', '), ')');
+            if (argsLine.length > MAX_LINE_LENGTH) {
+                argsLine = prefix + wrap('(\n', indent(join(args, '\n')), '\n)');
+            }
+            return join([argsLine, join(directives, ' '), selectionSet], ' ');
+        },
+    },
+    Argument: { leave: ({ name, value }) => name + ': ' + value },
+    // Fragments
+    FragmentSpread: {
+        leave: ({ name, directives }) => '...' + name + wrap(' ', join(directives, ' ')),
+    },
+    InlineFragment: {
+        leave: ({ typeCondition, directives, selectionSet }) => join(['...', wrap('on ', typeCondition), join(directives, ' '), selectionSet], ' '),
+    },
+    FragmentDefinition: {
+        leave: ({ name, typeCondition, variableDefinitions, directives, selectionSet }) => 
+        // Note: fragment variable definitions are experimental and may be changed
+        // or removed in the future.
+        `fragment ${name}${wrap('(', join(variableDefinitions, ', '), ')')} ` +
+            `on ${typeCondition} ${wrap('', join(directives, ' '), ' ')}` +
+            selectionSet,
+    },
+    // Value
+    IntValue: { leave: ({ value }) => value },
+    FloatValue: { leave: ({ value }) => value },
+    StringValue: {
+        leave: ({ value, block: isBlockString }) => {
+            if (isBlockString) {
+                return printBlockString(value);
+            }
+            return JSON.stringify(value);
+        },
+    },
+    BooleanValue: { leave: ({ value }) => (value ? 'true' : 'false') },
+    NullValue: { leave: () => 'null' },
+    EnumValue: { leave: ({ value }) => value },
+    ListValue: { leave: ({ values }) => '[' + join(values, ', ') + ']' },
+    ObjectValue: { leave: ({ fields }) => '{' + join(fields, ', ') + '}' },
+    ObjectField: { leave: ({ name, value }) => name + ': ' + value },
+    // Directive
+    Directive: {
+        leave: ({ name, arguments: args }) => '@' + name + wrap('(', join(args, ', '), ')'),
+    },
+    // Type
+    NamedType: { leave: ({ name }) => name },
+    ListType: { leave: ({ type }) => '[' + type + ']' },
+    NonNullType: { leave: ({ type }) => type + '!' },
+    // Type System Definitions
+    SchemaDefinition: {
+        leave: ({ directives, operationTypes }) => join(['schema', join(directives, ' '), block(operationTypes)], ' '),
+    },
+    OperationTypeDefinition: {
+        leave: ({ operation, type }) => operation + ': ' + type,
+    },
+    ScalarTypeDefinition: {
+        leave: ({ name, directives }) => join(['scalar', name, join(directives, ' ')], ' '),
+    },
+    ObjectTypeDefinition: {
+        leave: ({ name, interfaces, directives, fields }) => join(['type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' '),
+    },
+    FieldDefinition: {
+        leave: ({ name, arguments: args, type, directives }) => name +
+            (hasMultilineItems(args)
+                ? wrap('(\n', indent(join(args, '\n')), '\n)')
+                : wrap('(', join(args, ', '), ')')) +
+            ': ' +
+            type +
+            wrap(' ', join(directives, ' ')),
+    },
+    InputValueDefinition: {
+        leave: ({ name, type, defaultValue, directives }) => join([name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ')], ' '),
+    },
+    InterfaceTypeDefinition: {
+        leave: ({ name, interfaces, directives, fields }) => join(['interface', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' '),
+    },
+    UnionTypeDefinition: {
+        leave: ({ name, directives, types }) => join(['union', name, join(directives, ' '), wrap('= ', join(types, ' | '))], ' '),
+    },
+    EnumTypeDefinition: {
+        leave: ({ name, directives, values }) => join(['enum', name, join(directives, ' '), block(values)], ' '),
+    },
+    EnumValueDefinition: {
+        leave: ({ name, directives }) => join([name, join(directives, ' ')], ' '),
+    },
+    InputObjectTypeDefinition: {
+        leave: ({ name, directives, fields }) => join(['input', name, join(directives, ' '), block(fields)], ' '),
+    },
+    DirectiveDefinition: {
+        leave: ({ name, arguments: args, repeatable, locations }) => 'directive @' +
+            name +
+            (hasMultilineItems(args)
+                ? wrap('(\n', indent(join(args, '\n')), '\n)')
+                : wrap('(', join(args, ', '), ')')) +
+            (repeatable ? ' repeatable' : '') +
+            ' on ' +
+            join(locations, ' | '),
+    },
+    SchemaExtension: {
+        leave: ({ directives, operationTypes }) => join(['extend schema', join(directives, ' '), block(operationTypes)], ' '),
+    },
+    ScalarTypeExtension: {
+        leave: ({ name, directives }) => join(['extend scalar', name, join(directives, ' ')], ' '),
+    },
+    ObjectTypeExtension: {
+        leave: ({ name, interfaces, directives, fields }) => join(['extend type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' '),
+    },
+    InterfaceTypeExtension: {
+        leave: ({ name, interfaces, directives, fields }) => join(['extend interface', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' '),
+    },
+    UnionTypeExtension: {
+        leave: ({ name, directives, types }) => join(['extend union', name, join(directives, ' '), wrap('= ', join(types, ' | '))], ' '),
+    },
+    EnumTypeExtension: {
+        leave: ({ name, directives, values }) => join(['extend enum', name, join(directives, ' '), block(values)], ' '),
+    },
+    InputObjectTypeExtension: {
+        leave: ({ name, directives, fields }) => join(['extend input', name, join(directives, ' '), block(fields)], ' '),
+    },
+};
+const printDocASTReducerWithComments = Object.keys(printDocASTReducer).reduce((prev, key) => ({
+    ...prev,
+    [key]: {
+        leave: addDescription(printDocASTReducer[key].leave),
+    },
+}), {});
+/**
+ * Converts an AST into a string, using one set of reasonable
+ * formatting rules.
+ */
+export function printWithComments(ast) {
+    return visit(ast, printDocASTReducerWithComments);
+}
+function isFieldDefinitionNode(node) {
+    return node.kind === 'FieldDefinition';
+}
+// graphql < v13 and > v15 does not export getDescription
+export function getDescription(node, options) {
+    if (node.description != null) {
+        return node.description.value;
+    }
+    if (options === null || options === void 0 ? void 0 : options.commentDescriptions) {
+        return getComment(node);
+    }
+}
+export function getComment(node) {
+    const rawValue = getLeadingCommentBlock(node);
+    if (rawValue !== undefined) {
+        return dedentBlockStringValue(`\n${rawValue}`);
+    }
+}
+export function getLeadingCommentBlock(node) {
+    const loc = node.loc;
+    if (!loc) {
+        return;
+    }
+    const comments = [];
+    let token = loc.startToken.prev;
+    while (token != null &&
+        token.kind === TokenKind.COMMENT &&
+        token.next != null &&
+        token.prev != null &&
+        token.line + 1 === token.next.line &&
+        token.line !== token.prev.line) {
+        const value = String(token.value);
+        comments.push(value);
+        token = token.prev;
+    }
+    return comments.length > 0 ? comments.reverse().join('\n') : undefined;
+}
+export function dedentBlockStringValue(rawString) {
+    // Expand a block string's raw value into independent lines.
+    const lines = rawString.split(/\r\n|[\n\r]/g);
+    // Remove common indentation from all lines but first.
+    const commonIndent = getBlockStringIndentation(lines);
+    if (commonIndent !== 0) {
+        for (let i = 1; i < lines.length; i++) {
+            lines[i] = lines[i].slice(commonIndent);
+        }
+    }
+    // Remove leading and trailing blank lines.
+    while (lines.length > 0 && isBlank(lines[0])) {
+        lines.shift();
+    }
+    while (lines.length > 0 && isBlank(lines[lines.length - 1])) {
+        lines.pop();
+    }
+    // Return a string of the lines joined with U+000A.
+    return lines.join('\n');
+}
+/**
+ * @internal
+ */
+export function getBlockStringIndentation(lines) {
+    let commonIndent = null;
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        const indent = leadingWhitespace(line);
+        if (indent === line.length) {
+            continue; // skip empty lines
+        }
+        if (commonIndent === null || indent < commonIndent) {
+            commonIndent = indent;
+            if (commonIndent === 0) {
+                break;
+            }
+        }
+    }
+    return commonIndent === null ? 0 : commonIndent;
+}
+function leadingWhitespace(str) {
+    let i = 0;
+    while (i < str.length && (str[i] === ' ' || str[i] === '\t')) {
+        i++;
+    }
+    return i;
+}
+function isBlank(str) {
+    return leadingWhitespace(str) === str.length;
+}

package/esm/errors.js

@@ -0,0 +1,17 @@
+import { GraphQLError, versionInfo } from 'graphql';
+export function createGraphQLError(message, options) {
+    if (versionInfo.major >= 17) {
+        return new GraphQLError(message, options);
+    }
+    return new GraphQLError(message, options === null || options === void 0 ? void 0 : options.nodes, options === null || options === void 0 ? void 0 : options.source, options === null || options === void 0 ? void 0 : options.positions, options === null || options === void 0 ? void 0 : options.path, options === null || options === void 0 ? void 0 : options.originalError, options === null || options === void 0 ? void 0 : options.extensions);
+}
+export function relocatedError(originalError, path) {
+    return createGraphQLError(originalError.message, {
+        nodes: originalError.nodes,
+        source: originalError.source,
+        positions: originalError.positions,
+        path: path == null ? originalError.path : path,
+        originalError,
+        extensions: originalError.extensions,
+    });
+}

package/esm/executor.js

@@ -0,0 +1 @@
+export {};

package/esm/fields.js

@@ -0,0 +1,108 @@
+import { GraphQLObjectType } from 'graphql';
+import { MapperKind } from './Interfaces.js';
+import { mapSchema, correctASTNodes } from './mapSchema.js';
+import { addTypes } from './addTypes.js';
+export function appendObjectFields(schema, typeName, additionalFields) {
+    if (schema.getType(typeName) == null) {
+        return addTypes(schema, [
+            new GraphQLObjectType({
+                name: typeName,
+                fields: additionalFields,
+            }),
+        ]);
+    }
+    return mapSchema(schema, {
+        [MapperKind.OBJECT_TYPE]: type => {
+            if (type.name === typeName) {
+                const config = type.toConfig();
+                const originalFieldConfigMap = config.fields;
+                const newFieldConfigMap = {};
+                for (const fieldName in originalFieldConfigMap) {
+                    newFieldConfigMap[fieldName] = originalFieldConfigMap[fieldName];
+                }
+                for (const fieldName in additionalFields) {
+                    newFieldConfigMap[fieldName] = additionalFields[fieldName];
+                }
+                return correctASTNodes(new GraphQLObjectType({
+                    ...config,
+                    fields: newFieldConfigMap,
+                }));
+            }
+        },
+    });
+}
+export function removeObjectFields(schema, typeName, testFn) {
+    const removedFields = {};
+    const newSchema = mapSchema(schema, {
+        [MapperKind.OBJECT_TYPE]: type => {
+            if (type.name === typeName) {
+                const config = type.toConfig();
+                const originalFieldConfigMap = config.fields;
+                const newFieldConfigMap = {};
+                for (const fieldName in originalFieldConfigMap) {
+                    const originalFieldConfig = originalFieldConfigMap[fieldName];
+                    if (testFn(fieldName, originalFieldConfig)) {
+                        removedFields[fieldName] = originalFieldConfig;
+                    }
+                    else {
+                        newFieldConfigMap[fieldName] = originalFieldConfig;
+                    }
+                }
+                return correctASTNodes(new GraphQLObjectType({
+                    ...config,
+                    fields: newFieldConfigMap,
+                }));
+            }
+        },
+    });
+    return [newSchema, removedFields];
+}
+export function selectObjectFields(schema, typeName, testFn) {
+    const selectedFields = {};
+    mapSchema(schema, {
+        [MapperKind.OBJECT_TYPE]: type => {
+            if (type.name === typeName) {
+                const config = type.toConfig();
+                const originalFieldConfigMap = config.fields;
+                for (const fieldName in originalFieldConfigMap) {
+                    const originalFieldConfig = originalFieldConfigMap[fieldName];
+                    if (testFn(fieldName, originalFieldConfig)) {
+                        selectedFields[fieldName] = originalFieldConfig;
+                    }
+                }
+            }
+            return undefined;
+        },
+    });
+    return selectedFields;
+}
+export function modifyObjectFields(schema, typeName, testFn, newFields) {
+    const removedFields = {};
+    const newSchema = mapSchema(schema, {
+        [MapperKind.OBJECT_TYPE]: type => {
+            if (type.name === typeName) {
+                const config = type.toConfig();
+                const originalFieldConfigMap = config.fields;
+                const newFieldConfigMap = {};
+                for (const fieldName in originalFieldConfigMap) {
+                    const originalFieldConfig = originalFieldConfigMap[fieldName];
+                    if (testFn(fieldName, originalFieldConfig)) {
+                        removedFields[fieldName] = originalFieldConfig;
+                    }
+                    else {
+                        newFieldConfigMap[fieldName] = originalFieldConfig;
+                    }
+                }
+                for (const fieldName in newFields) {
+                    const fieldConfig = newFields[fieldName];
+                    newFieldConfigMap[fieldName] = fieldConfig;
+                }
+                return correctASTNodes(new GraphQLObjectType({
+                    ...config,
+                    fields: newFieldConfigMap,
+                }));
+            }
+        },
+    });
+    return [newSchema, removedFields];
+}

package/esm/filterSchema.js

@@ -0,0 +1,62 @@
+import { GraphQLInputObjectType, GraphQLInterfaceType, GraphQLObjectType, } from 'graphql';
+import { MapperKind } from './Interfaces.js';
+import { mapSchema } from './mapSchema.js';
+export function filterSchema({ schema, typeFilter = () => true, fieldFilter = undefined, rootFieldFilter = undefined, objectFieldFilter = undefined, interfaceFieldFilter = undefined, inputObjectFieldFilter = undefined, argumentFilter = undefined, }) {
+    const filteredSchema = mapSchema(schema, {
+        [MapperKind.QUERY]: (type) => filterRootFields(type, 'Query', rootFieldFilter, argumentFilter),
+        [MapperKind.MUTATION]: (type) => filterRootFields(type, 'Mutation', rootFieldFilter, argumentFilter),
+        [MapperKind.SUBSCRIPTION]: (type) => filterRootFields(type, 'Subscription', rootFieldFilter, argumentFilter),
+        [MapperKind.OBJECT_TYPE]: (type) => typeFilter(type.name, type)
+            ? filterElementFields(GraphQLObjectType, type, objectFieldFilter || fieldFilter, argumentFilter)
+            : null,
+        [MapperKind.INTERFACE_TYPE]: (type) => typeFilter(type.name, type)
+            ? filterElementFields(GraphQLInterfaceType, type, interfaceFieldFilter || fieldFilter, argumentFilter)
+            : null,
+        [MapperKind.INPUT_OBJECT_TYPE]: (type) => typeFilter(type.name, type)
+            ? filterElementFields(GraphQLInputObjectType, type, inputObjectFieldFilter || fieldFilter)
+            : null,
+        [MapperKind.UNION_TYPE]: (type) => (typeFilter(type.name, type) ? undefined : null),
+        [MapperKind.ENUM_TYPE]: (type) => (typeFilter(type.name, type) ? undefined : null),
+        [MapperKind.SCALAR_TYPE]: (type) => (typeFilter(type.name, type) ? undefined : null),
+    });
+    return filteredSchema;
+}
+function filterRootFields(type, operation, rootFieldFilter, argumentFilter) {
+    if (rootFieldFilter || argumentFilter) {
+        const config = type.toConfig();
+        for (const fieldName in config.fields) {
+            const field = config.fields[fieldName];
+            if (rootFieldFilter && !rootFieldFilter(operation, fieldName, config.fields[fieldName])) {
+                delete config.fields[fieldName];
+            }
+            else if (argumentFilter && field.args) {
+                for (const argName in field.args) {
+                    if (!argumentFilter(operation, fieldName, argName, field.args[argName])) {
+                        delete field.args[argName];
+                    }
+                }
+            }
+        }
+        return new GraphQLObjectType(config);
+    }
+    return type;
+}
+function filterElementFields(ElementConstructor, type, fieldFilter, argumentFilter) {
+    if (fieldFilter || argumentFilter) {
+        const config = type.toConfig();
+        for (const fieldName in config.fields) {
+            const field = config.fields[fieldName];
+            if (fieldFilter && !fieldFilter(type.name, fieldName, config.fields[fieldName])) {
+                delete config.fields[fieldName];
+            }
+            else if (argumentFilter && 'args' in field) {
+                for (const argName in field.args) {
+                    if (!argumentFilter(type.name, fieldName, argName, field.args[argName])) {
+                        delete field.args[argName];
+                    }
+                }
+            }
+        }
+        return new ElementConstructor(config);
+    }
+}

package/esm/fixSchemaAst.js

@@ -0,0 +1,22 @@
+import { buildASTSchema } from 'graphql';
+import { getDocumentNodeFromSchema } from './print-schema-with-directives.js';
+function buildFixedSchema(schema, options) {
+    const document = getDocumentNodeFromSchema(schema);
+    return buildASTSchema(document, {
+        ...(options || {}),
+    });
+}
+export function fixSchemaAst(schema, options) {
+    // eslint-disable-next-line no-undef-init
+    let schemaWithValidAst = undefined;
+    if (!schema.astNode || !schema.extensionASTNodes) {
+        schemaWithValidAst = buildFixedSchema(schema, options);
+    }
+    if (!schema.astNode && (schemaWithValidAst === null || schemaWithValidAst === void 0 ? void 0 : schemaWithValidAst.astNode)) {
+        schema.astNode = schemaWithValidAst.astNode;
+    }
+    if (!schema.extensionASTNodes && (schemaWithValidAst === null || schemaWithValidAst === void 0 ? void 0 : schemaWithValidAst.astNode)) {
+        schema.extensionASTNodes = schemaWithValidAst.extensionASTNodes;
+    }
+    return schema;
+}

package/esm/forEachDefaultValue.js

@@ -0,0 +1,25 @@
+import { getNamedType, isObjectType, isInputObjectType } from 'graphql';
+export function forEachDefaultValue(schema, fn) {
+    const typeMap = schema.getTypeMap();
+    for (const typeName in typeMap) {
+        const type = typeMap[typeName];
+        if (!getNamedType(type).name.startsWith('__')) {
+            if (isObjectType(type)) {
+                const fields = type.getFields();
+                for (const fieldName in fields) {
+                    const field = fields[fieldName];
+                    for (const arg of field.args) {
+                        arg.defaultValue = fn(arg.type, arg.defaultValue);
+                    }
+                }
+            }
+            else if (isInputObjectType(type)) {
+                const fields = type.getFields();
+                for (const fieldName in fields) {
+                    const field = fields[fieldName];
+                    field.defaultValue = fn(field.type, field.defaultValue);
+                }
+            }
+        }
+    }
+}

package/esm/forEachField.js

@@ -0,0 +1,15 @@
+import { getNamedType, isObjectType } from 'graphql';
+export function forEachField(schema, fn) {
+    const typeMap = schema.getTypeMap();
+    for (const typeName in typeMap) {
+        const type = typeMap[typeName];
+        // TODO: maybe have an option to include these?
+        if (!getNamedType(type).name.startsWith('__') && isObjectType(type)) {
+            const fields = type.getFields();
+            for (const fieldName in fields) {
+                const field = fields[fieldName];
+                fn(field, typeName, fieldName);
+            }
+        }
+    }
+}