@theguild/federation-composition/esm/graphql/sort-sdl.js

Open Source Composition library for Apollo Federation

import { Kind, parse, stripIgnoredCharacters, visit, } from "graphql";
import sortBy from "lodash.sortby";
import { print } from "./printer.js";
export function sortSDL(doc) {
    try {
        return visit(doc, {
            Document(node) {
                return {
                    ...node,
                    definitions: sortNodes(node.definitions),
                };
            },
            SchemaDefinition(node) {
                return {
                    ...node,
                    directives: sortNodes(node.directives),
                };
            },
            ScalarTypeDefinition(node) {
                return {
                    ...node,
                    directives: sortNodes(node.directives),
                };
            },
            ObjectTypeDefinition(node) {
                return {
                    ...node,
                    directives: sortNodes(node.directives),
                    fields: sortNodes(node.fields),
                    interfaces: sortNodes(node.interfaces),
                };
            },
            InterfaceTypeDefinition(node) {
                return {
                    ...node,
                    directives: sortNodes(node.directives),
                    fields: sortNodes(node.fields),
                };
            },
            InputObjectTypeDefinition(node) {
                return {
                    ...node,
                    directives: sortNodes(node.directives),
                    fields: sortNodes(node.fields),
                };
            },
            EnumTypeDefinition(node) {
                return {
                    ...node,
                    directives: sortNodes(node.directives),
                    values: sortNodes(node.values),
                };
            },
            EnumValueDefinition(node) {
                return {
                    ...node,
                    directives: sortNodes(node.directives),
                };
            },
            UnionTypeDefinition(node) {
                return {
                    ...node,
                    types: sortNodes(node.types),
                    directives: sortNodes(node.directives),
                };
            },
            FieldDefinition(node) {
                return {
                    ...node,
                    directives: sortNodes(node.directives),
                };
            },
            DirectiveDefinition(node) {
                return {
                    ...node,
                    locations: sortNodes(node.locations),
                };
            },
            Directive(node) {
                for (const arg of node.arguments ?? []) {
                    if (["requires", "provides"].includes(arg.name.value) &&
                        arg.value.kind === Kind.STRING) {
                        const parsedFields = parseFields(arg.value.value);
                        if (parsedFields) {
                            const printed = stripIgnoredCharacters(print(parsedFields));
                            arg.value.value = printed
                                .replace(/^\{/, "")
                                .replace(/\}$/, "");
                        }
                    }
                }
                return {
                    ...node,
                    arguments: sortNodes(node.arguments),
                };
            },
            StringValue(node) {
                return {
                    ...node,
                    value: node.value.trim(),
                };
            },
        });
    }
    catch (error) {
        console.log("Failed to parse", doc.loc?.source.name);
        throw error;
    }
}
function parseFields(fields) {
    const parsed = parse(fields.trim().startsWith(`{`) ? `query ${fields}` : `query { ${fields} }`).definitions.find((d) => d.kind === Kind.OPERATION_DEFINITION);
    return parsed?.selectionSet;
}
function valueNodeToString(node) {
    if ("name" in node) {
        return node.name.value;
    }
    if ("value" in node) {
        return node.value.toString();
    }
    if (node.kind === Kind.LIST) {
        return node.values.map(valueNodeToString).join(",");
    }
    if (node.kind === Kind.OBJECT) {
        return "OBJECT";
    }
    return "NULL";
}
function sortNodes(nodes) {
    if (nodes) {
        if (nodes.length === 0) {
            return [];
        }
        if (isOfKindList(nodes, Kind.NAMED_TYPE)) {
            return sortBy(nodes, "name.value");
        }
        if (isOfKindList(nodes, Kind.DIRECTIVE)) {
            return sortBy(nodes, (n) => {
                const args = n.arguments
                    ?.map((a) => a.name.value + valueNodeToString(a.value))
                    .sort()
                    .join(";") ?? "";
                return n.name.value + args;
            });
        }
        if (isOfKindList(nodes, Kind.VARIABLE_DEFINITION)) {
            return sortBy(nodes, "variable.name.value");
        }
        if (isOfKindList(nodes, Kind.ARGUMENT)) {
            return sortBy(nodes, "name.value");
        }
        if (isOfKindList(nodes, Kind.ENUM_VALUE_DEFINITION)) {
            return sortBy(nodes, "name.value");
        }
        if (isOfKindList(nodes, Kind.INPUT_VALUE_DEFINITION)) {
            return sortBy(nodes, "name.value");
        }
        if (isOfKindList(nodes, [
            Kind.FIELD,
            Kind.FRAGMENT_SPREAD,
            Kind.INLINE_FRAGMENT,
        ])) {
            return sortBy(nodes, "kind", "name.value");
        }
        if (isOfKindList(nodes, Kind.NAME)) {
            return sortBy(nodes, "value");
        }
        return sortBy(nodes, "kind", "name.value");
    }
    return;
}
function isOfKindList(nodes, kind) {
    return typeof kind === "string"
        ? nodes[0].kind === kind
        : kind.includes(nodes[0].kind);
}