@theguild/federation-composition/esm/graphql/printer.js

Open Source Composition library for Apollo Federation

function printString(string) {
    return JSON.stringify(string);
}
function printBlockString(string) {
    return '"""\n' + string.replace(/"""/g, '\\"""') + '\n"""';
}
const nodes = {
    Document(node) {
        return node.definitions?.length > 0 ? node.definitions.map(print).join('\n\n') : '';
    },
    OperationDefinition(node) {
        if (node.operation === 'query' &&
            !node.name &&
            !node.variableDefinitions?.length &&
            !node.directives?.length) {
            return print(node.selectionSet);
        }
        return (join([
            node.operation,
            print(node.name) + wrap('(', join(node.variableDefinitions?.map(print), ', '), ')'),
            join(node.directives?.map(print), ' '),
        ], ' ') + print(node.selectionSet));
    },
    VariableDefinition(node) {
        return [
            print(node.variable),
            ':',
            print(node.type),
            wrap(' = ', print(node.defaultValue)),
            join(node.directives?.map(print), ' '),
        ].join(' ');
    },
    Field(node) {
        return (join([
            (node.alias ? node.alias.value + ': ' : '') + node.name.value + printArgs(node.arguments),
            join(node.directives?.map(print), ' '),
        ], ' ') + print(node.selectionSet));
    },
    StringValue(node) {
        return node.block ? printBlockString(node.value) : printString(node.value);
    },
    BooleanValue(node) {
        return '' + node.value;
    },
    NullValue(_node) {
        return 'null';
    },
    IntValue(node) {
        return node.value;
    },
    FloatValue(node) {
        return node.value;
    },
    EnumValue(node) {
        return node.value;
    },
    Name(node) {
        return node.value;
    },
    Variable(node) {
        return '$' + node.name.value;
    },
    ListValue(node) {
        return '[' + node.values.map(print).join(', ') + ']';
    },
    ObjectValue(node) {
        return '{' + node.fields.map(print).join(', ') + '}';
    },
    ObjectField(node) {
        return node.name.value + ': ' + print(node.value);
    },
    SelectionSet(node) {
        return block(node.selections.map(print));
    },
    Argument(node) {
        return node.name.value + ': ' + print(node.value);
    },
    FragmentSpread(node) {
        return join(['...', print(node.name), join(node.directives?.map(print), ' ')], ' ');
    },
    InlineFragment(node) {
        return join([
            '...',
            node.typeCondition ? 'on ' + node.typeCondition.name.value : '',
            join(node.directives?.map(print), ' '),
            print(node.selectionSet),
        ], ' ');
    },
    FragmentDefinition(node) {
        return join([
            'fragment',
            print(node.name),
            'on',
            node.typeCondition.name.value,
            join(node.directives?.map(print), ' '),
            print(node.selectionSet),
        ]);
    },
    Directive(node) {
        return '@' + node.name.value + printArgs(node.arguments);
    },
    NamedType(node) {
        return node.name.value;
    },
    ListType(node) {
        return '[' + print(node.type) + ']';
    },
    NonNullType(node) {
        return print(node.type) + '!';
    },
    SchemaDefinition(node) {
        return join(['schema', join(node.directives?.map(print), ' '), block(node.operationTypes?.map(print))], ' ');
    },
    OperationTypeDefinition(node) {
        return node.operation + ': ' + print(node.type);
    },
    ScalarTypeDefinition(node) {
        return (wrap('', print(node.description), '\n') +
            join(['scalar', print(node.name), join(node.directives?.map(print), ' ')], ' '));
    },
    ObjectTypeDefinition(node) {
        return (wrap('', print(node.description), '\n') +
            join([
                'type',
                print(node.name),
                wrap('implements ', join(node.interfaces?.map(print), ' & ')),
                join(node.directives?.map(print), ' '),
                block(node.fields?.map(print)),
            ], ' '));
    },
    InterfaceTypeDefinition(node) {
        return (wrap('', print(node.description), '\n') +
            join([
                'interface',
                print(node.name),
                wrap('implements ', join(node.interfaces?.map(print), ' & ')),
                join(node.directives?.map(print), ' '),
                block(node.fields?.map(print)),
            ], ' '));
    },
    InputObjectTypeDefinition(node) {
        return (wrap('', print(node.description), '\n') +
            join([
                'input',
                print(node.name),
                join(node.directives?.map(print), ' '),
                block(node.fields?.map(print)),
            ], ' '));
    },
    UnionTypeDefinition(node) {
        return (wrap('', print(node.description), '\n') +
            join([
                'union',
                print(node.name),
                join(node.directives?.map(print), ' '),
                wrap('= ', join(node.types?.map(print), ' | ')),
            ], ' '));
    },
    EnumTypeDefinition(node) {
        return (wrap('', print(node.description), '\n') +
            join([
                'enum',
                print(node.name),
                join(node.directives?.map(print), ' '),
                block(node.values?.map(print)),
            ], ' '));
    },
    EnumValueDefinition(node) {
        return (wrap('', print(node.description), '\n') +
            join([print(node.name), join(node.directives?.map(print), ' ')], ' '));
    },
    FieldDefinition(node) {
        return (wrap('', print(node.description), '\n') +
            print(node.name) +
            printArgs(node.arguments) +
            ': ' +
            print(node.type) +
            wrap(' ', join(node.directives?.map(print), ' ')));
    },
    InputValueDefinition(node) {
        return (wrap('', print(node.description), '\n') +
            join([
                print(node.name) + ': ' + print(node.type),
                wrap('= ', print(node.defaultValue)),
                join(node.directives?.map(print), ' '),
            ], ' '));
    },
    DirectiveDefinition(node) {
        return (wrap('', print(node.description), '\n') +
            'directive @' +
            print(node.name) +
            printArgs(node.arguments) +
            (node.repeatable ? ' repeatable' : '') +
            ' on ' +
            join(node.locations?.map(print), ' | '));
    },
    SchemaExtension() {
        return '';
    },
    ScalarTypeExtension() {
        return '';
    },
    ObjectTypeExtension() {
        return '';
    },
    InterfaceTypeExtension() {
        return '';
    },
    UnionTypeExtension() {
        return '';
    },
    EnumTypeExtension() {
        return '';
    },
    InputObjectTypeExtension() {
        return '';
    },
};
export function print(node) {
    if (!node) {
        return '';
    }
    return nodes[node.kind] ? nodes[node.kind](node) : '';
}
function printArgs(nodes) {
    if (!nodes || nodes.length === 0) {
        return '';
    }
    const args = nodes.map(print);
    const argsLine = '(' + args.join(', ') + ') ';
    return argsLine.length > 80 ? '(\n  ' + args.join('\n').replace(/\n/g, '\n  ') + '\n)' : argsLine;
}
function block(array) {
    return wrap('{\n', indent(join(array, '\n')), '\n}');
}
function indent(str) {
    return wrap('  ', str.replaceAll('\n', '\n  '));
}
function wrap(start, maybeString, end = '') {
    return maybeString != null && maybeString !== '' ? start + maybeString + end : '';
}
function join(maybeArray, separator = '') {
    return maybeArray?.filter(x => x).join(separator) ?? '';
}