Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Update dependency com.graphql-java:graphql-java to v20 #726

Merged
merged 1 commit into from
Feb 24, 2023
Merged

Update dependency com.graphql-java:graphql-java to v20 #726

merged 1 commit into from
Feb 24, 2023

Conversation

renovate[bot]
Copy link
Contributor

@renovate renovate bot commented Dec 7, 2022 •
edited
Loading

Mend Renovate

This PR contains the following updates:

Package Change Age Adoption Passing Confidence
com.graphql-java:graphql-java 19.2 -> 20.0 age adoption passing confidence

Release Notes

graphql-java/graphql-java

v20.0: 20.0

We are pleased to announce the release of graphql-java 20.0. Special thanks to each of the 200+ contributors over the years, who have made this milestone possible.

Breaking changes

Aligning parseValue coercion with JS reference implementation

We have made changes to String, Boolean, Float, and Int parseValue coercion, to be consistent with the reference JS implementation. The key change is parseValue is now stricter on accepted inputs.

  • String parseValue now requires input is of type String. For example, a Number input 123 or a Boolean input true will no longer be accepted.
  • Boolean parseValue now requires input is of type Boolean. For example, a String input "true" will no longer be accepted.
  • Float parseValue now requires input is of type Number. For example, a String input "3.14" will no longer be accepted.
  • Int parseValue now requires input is of type Number. For example, a String input "42" will no longer be accepted.

String parseValue changes: https://github.com/graphql-java/graphql-java/pull/3030
Boolean, Float, and Int parseValue changes: https://github.com/graphql-java/graphql-java/pull/3042
JS reference implementation: https://github.com/graphql/graphql-js/blob/main/src/type/scalars.ts

Notable Changes

Record Like Property Fetching Support

We have now added the ability to find properties via "Record like" naming. We call it "Record like" based on Java 14 record classes but in fact any class with a method named directly as the graphql field is named will work.

If you had this graphql object type declared

type Person {
   name : String
   address : String
}

then this Java record would be supported for fetching values via the method names name() and address()

public record Person (String name, String address)

and equally a non record class like this would also work

public class Person {
   public String name() { return "Harry Potter"; }
   public String address() { return "4 Privet Drive, Little Whinging"; }
}

We still have Java Bean (aka POJO) getter naming support like public String getName() however now the "record like" name() method will be used in preference and then the getName() methods will be used if that's not present.

This means there is a new behavior if you had weird POJOs likes this

public class WeirdPerson {
   public String name() { return "Harry Potter"; }
   public String getName() { return "Tom Riddle"; }
}

A property fetch for name will now return Harry Potter and not Tom Riddle as it previously would have.

This is a behavioral breaking change but on balance we think this behavior is the most correct going forward.

https://github.com/graphql-java/graphql-java/pull/2994

Improved Data Fetching

The PropertyDataFetcher class is the most common data fetcher used in graphql-java. It uses Java reflection to get field values from objects based on field name.

This was logically the following

Method method = findMethod(fieldname);
method.invoke(object);

with the method lookup cached for performance reasons.

However there is mechanism in the JVM that provides even faster object reflective access.

See

https://wttech.blog/blog/2020/method-handles-and-lambda-metafactory/
https://www.optaplanner.org/blog/2018/01/09/JavaReflectionButMuchFaster.html

java.lang.invoke.LambdaMetafactory#metafactory is an arcane mechanism that can be used to create virtual method lambdas that give fast access to call object methods. It turns out to be significantly faster that Java reflection and only marginally slower that directly invoking a method.

If you use PropertyDataFetcher a lot (and chances are you do) then this should give improved performance.

The raw benchmarks are as follows

Java 8

Benchmark                                       Mode  Cnt         Score         Error  Units
GetterAccessBenchmark.measureDirectAccess      thrpt   15  81199548.105 ± 2717206.756  ops/s 0% slower (baseline)
GetterAccessBenchmark.measureLambdaAccess      thrpt   15  79622345.446 ± 1183553.379  ops/s 2% slower
GetterAccessBenchmark.measureReflectionAccess  thrpt   15  46102664.133 ± 4091595.318  ops/s 50% slower

Java 17

Benchmark                                       Mode  Cnt          Score          Error  Units
GetterAccessBenchmark.measureDirectAccess      thrpt   15  458411420.717 ± 34329506.990  ops/s 0%
GetterAccessBenchmark.measureLambdaAccess      thrpt   15  334158880.091 ± 10666070.698  ops/s 27% slower
GetterAccessBenchmark.measureReflectionAccess  thrpt   15   63181868.566 ±  3887367.970  ops/s  86% slower

It's worth noting that while the headline numbers here look impressive, the property fetching represents a smaller portion of what happens during graphql engine execution.

It probably won't be enough to keep Elon Musk happy but all performance improvements help and at scale they help the most.

Lightweight Data Fetchers

A DataFetcher gets invoked with a calling environment context object called graphql.schema.DataFetchingEnvironment. This is quite a rich object that contains all sorts of useful information.

However simple (aka trivial) data fetchers like PropertyDataFetcher they don't need access to such a rich object. They just need the source object, the field name and the field type

To marginally help performance, we have introduced a graphql.schema.LightDataFetcher for this use case

public interface LightDataFetcher<T> extends TrivialDataFetcher<T> {

    
    T get(GraphQLFieldDefinition fieldDefinition, Object sourceObject, Supplier<DataFetchingEnvironment> environmentSupplier) throws Exception;
}

PropertyDataFetcher implements this and hence this lowers the object allocation at scale (which reduces memory pressure) and will make the system marginally faster to fetch data.

https://github.com/graphql-java/graphql-java/pull/2953

Performance Improvements by avoid object allocations

We are always trying to wring out the most performance we can in graphql-java and so we reviewed our object allocations and found places where we can make savings.

These won't make dramatic performance savings but at scale all these things add up, reducing memory pressure and improving throughput marginally.

https://github.com/graphql-java/graphql-java/pull/2981
https://github.com/graphql-java/graphql-java/pull/2980
https://github.com/graphql-java/graphql-java/pull/2979

Locale is now available in Coercing and Parsing

The graphql.schema.Coercing interface used by scalars can now receive a Locale object that indicates the calling Locale. The same is true for the parsing code via graphql.parser.ParserEnvironment#getLocale

A custom scalar implementation could use the locale to decide how to coerce values.

https://github.com/graphql-java/graphql-java/pull/2912
https://github.com/graphql-java/graphql-java/pull/2921

Easier ways to build common objects

We have added extra builders on the GraphQLError, ErrorClassification and ExecutionResult interfaces that make it easier to build instances of these common classes.

https://github.com/graphql-java/graphql-java/pull/2939
https://github.com/graphql-java/graphql-java/pull/3011

The deprecated NextGen engine has been removed

The NextGen engine was an experimental feature that explored what it might take to build a new graphql engine. In many ways it was a success as it taught us a bunch of about graph algorithms and what works and what does not.

While it had some value, on balance it was not going to become production ready and so we deprecated it a while back and it has finally been removed.

https://github.com/graphql-java/graphql-java/pull/2923

What's Changed

New Contributors

Full Changelog: graphql-java/graphql-java@v19.1...v20.0

v19.3: 19.3

The 19.3 bug fix release has been created

What's Changed

Full Changelog: graphql-java/graphql-java@v19.2...v19.3

Configuration

📅 Schedule: Branch creation - At any time (no schedule defined), Automerge - At any time (no schedule defined).

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

  • If you want to rebase/retry this PR, check this box

This PR has been generated by Mend Renovate. View repository job log here.

@renovate renovate bot added the dependencies Pull requests that update a dependency file label Dec 7, 2022
@rrva
Copy link
Contributor

rrva commented Dec 14, 2022

I have run some tests and works fine in my application.

@lburja
Copy link
Contributor

lburja commented Dec 15, 2022

I have also run some tests, and it seems to work well for my application

@lburja
Copy link
Contributor

lburja commented Feb 6, 2023

@oryan-block Can we merge this? Are there any particular concerns with migrating to graphql-java v20?

1 similar comment
@lburja
Copy link
Contributor

lburja commented Feb 6, 2023

@oryan-block Can we merge this? Are there any particular concerns with migrating to graphql-java v20?

@oryan-block
Copy link
Collaborator

@lburja there are breaking changes in this release and I've seen some tests fail so it'll take a bit of work to merge this.

@oryan-block oryan-block merged commit fcb0cb8 into master Feb 24, 2023
@oryan-block oryan-block deleted the renovate/major-graphql-java.version branch February 24, 2023 18:10
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Reviewers

@oryan-block oryan-block oryan-block approved these changes

Assignees
No one assigned
Labels
dependencies Pull requests that update a dependency file
Projects
None yet
Milestone
No milestone
Development

Successfully merging this pull request may close these issues.
3 participants
@rrva @lburja @oryan-block