public static Map<String, Object> replaceInputsWithVariableDeclaration(final GraphQLQuery query) {
    final var inputs = query.getInput();
    final var variables = Map.copyOf(inputs);
    final List<VariableDefinition> variableDefinitions = createVariableDefinitions(query);
    variableDefinitions.forEach(definition -> inputs.put(definition.getName(), new VariableReference(definition.getName())));
    query.getVariableDefinitions().addAll(variableDefinitions);
    return variables;
  }

  private static List<VariableDefinition> createVariableDefinitions(final GraphQLQuery query) {
    // Use the constructor with arguments to figure out what graphql types the inputs have.
    // NB This only works because the compiler has the `-parameters` flag set.
    Constructor<?> constructor = stream(query.getClass().getDeclaredConstructors()).filter(candidate -> candidate.getParameters().length > 0).findFirst().orElseThrow();
    var parametersByName = stream(constructor.getParameters()).collect(Collectors.toMap(Parameter::getName, Function.identity()));
    class VariableDefinitionFactory {

      Parameter get(final String name) {
        return Optional.ofNullable(parametersByName.get(name)).orElseThrow(
          () -> new IllegalStateException("No parameter found for name " + name + " in paramters " + parametersByName.keySet())
        );
      }
      VariableDefinition create(final String name) {
        return createVariableDefinition(get(name));
      }
      private VariableDefinition createVariableDefinition(final Parameter parameter) {
        return new VariableDefinition(parameter.getName(), convertType(parameter.getParameterizedType()));
      }
    }

    VariableDefinitionFactory factory = new VariableDefinitionFactory();
    return query.getInput().keySet().stream().map(factory::create).collect(Collectors.toList());
  }

  /**
   * Converts the java type to the graphql type.
   * Sadly this can't be inferred from the DGS codegen apart from via some yucky reflection.
   */
  private static Type<?> convertType(final java.lang.reflect.Type javaType) {
    if (javaType instanceof Class<?> type) {
      return new NonNullType(new TypeName(convertTypeName(type)));
    }
    if (javaType instanceof ParameterizedType parameterizedType) {
      final var rawType = parameterizedType.getRawType();
      if (rawType.equals(List.class)) {
        // If a list then recurse.
        final var listType = parameterizedType.getActualTypeArguments()[0];
        return new NonNullType(new ListType(convertType(listType)));
      }
    }
    throw new AssertionError("Unknown type " + javaType);
  }

  /**
   * For the generated classes and most scalars the simple name of the class will match the graphql type.
   */
  @NotNull
  private static String convertTypeName(final Class<?> type) {
    // `int.class` will do the right thing but not `Integer`.
    if (type.equals(Integer.class)) {
      return "Int";
    }
    String simpleName = type.getSimpleName();
    if (type.isPrimitive()) {
      // e.g. boolean.class => Boolean
      return simpleName.substring(0, 1).toUpperCase(Locale.ROOT) + simpleName.substring(1);
    }
    return simpleName;
  }