Breaking: Converts to Swift Concurrency

[NeedleInAJayStack]

This removes the NIO dependency. It is breaking because it removes all Swift NIO-isms that were present in the public APIs (like EventLoopFuture and EventLoopGroup argument/return types).

[NeedleInAJayStack]

Hey @adam-fowler & @paulofaria - I managed to get the tests passing, and I think this is ready for you guys to look again. Could you give it a pass on my changes following your comments?

[NeedleInAJayStack]

@paulofaria Okay, I'm feeling pretty confident in this - do you mind taking a look at the final changes and approving (again)? Thanks for the review!!

[paulofaria]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

Good point - I've poked at it a bit but haven't really figured out the size of the effort. Supporting strict concurrency will be a breaking change, so probably best to do it now if it's feasible. I'll take a look this weekend and see how much work it is. Thanks Paulo!

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

@paulofaria I got almost everything working with strict concurrency checking in this commit (compiling successfully, just 4 tests failing).

That said, I am throwing around unchecked a bit more than I would like. In particular, allowing circular references in the GraphQLSchema type system requires allowing the client to mutate the fields of a GraphQLObjectType, which inherintly makes it non-sendable. Reworking it as an actor is possible, but gives us an async explosion. The cleanest solution is probably to have a "definition" step where types are mutable and not sendable, and an "build" step that converts the entire schema to immutable types. I'm leaning toward just leaving it unchecked and documenting that the schema should not be mutated after starting to execute against it, because 1) it keeps us close to the JS reference implementation and 2) most people are using it this way already (and Graphiti's patterns strongly promote this).

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

@paulofaria I got almost everything working with strict concurrency checking in this commit (compiling successfully, just 4 tests failing).

That said, I am throwing around unchecked a bit more than I would like. In particular, allowing circular references in the GraphQLSchema type system requires allowing the client to mutate the fields of a GraphQLObjectType, which inherintly makes it non-sendable. Reworking it as an actor is possible, but gives us an async explosion. The cleanest solution is probably to have a "definition" step where types are mutable and not sendable, and an "build" step that converts the entire schema to immutable types. I'm leaning toward just leaving it unchecked and documenting that the schema should not be mutated after starting to execute against it, because 1) it keeps us close to the JS reference implementation and 2) most people are using it this way already (and Graphiti's patterns strongly promote this).

Okay, I got it working with strict concurrency, and I added some thread-safety to the unchecked classes. There are 3 unavoidable warnings that hopefully will be addressed by the compiler in the future. Also, I pulled in a few breaking quality-of-life changes, like removing execution strategy arguments, and improving default validation.

I'm going to go ahead and merge this! Thanks for the review!

[NeedleInAJayStack]

This removes the NIO dependency. It is breaking because it removes all Swift NIO-isms that were present in the public APIs (like EventLoopFuture and EventLoopGroup argument/return types).

[NeedleInAJayStack]

Hey @adam-fowler & @paulofaria - I managed to get the tests passing, and I think this is ready for you guys to look again. Could you give it a pass on my changes following your comments?

[NeedleInAJayStack]

@paulofaria Okay, I'm feeling pretty confident in this - do you mind taking a look at the final changes and approving (again)? Thanks for the review!!

[paulofaria]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

Good point - I've poked at it a bit but haven't really figured out the size of the effort. Supporting strict concurrency will be a breaking change, so probably best to do it now if it's feasible. I'll take a look this weekend and see how much work it is. Thanks Paulo!

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

@paulofaria I got almost everything working with strict concurrency checking in this commit (compiling successfully, just 4 tests failing).

That said, I am throwing around unchecked a bit more than I would like. In particular, allowing circular references in the GraphQLSchema type system requires allowing the client to mutate the fields of a GraphQLObjectType, which inherintly makes it non-sendable. Reworking it as an actor is possible, but gives us an async explosion. The cleanest solution is probably to have a "definition" step where types are mutable and not sendable, and an "build" step that converts the entire schema to immutable types. I'm leaning toward just leaving it unchecked and documenting that the schema should not be mutated after starting to execute against it, because 1) it keeps us close to the JS reference implementation and 2) most people are using it this way already (and Graphiti's patterns strongly promote this).

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

@paulofaria I got almost everything working with strict concurrency checking in this commit (compiling successfully, just 4 tests failing).

That said, I am throwing around unchecked a bit more than I would like. In particular, allowing circular references in the GraphQLSchema type system requires allowing the client to mutate the fields of a GraphQLObjectType, which inherintly makes it non-sendable. Reworking it as an actor is possible, but gives us an async explosion. The cleanest solution is probably to have a "definition" step where types are mutable and not sendable, and an "build" step that converts the entire schema to immutable types. I'm leaning toward just leaving it unchecked and documenting that the schema should not be mutated after starting to execute against it, because 1) it keeps us close to the JS reference implementation and 2) most people are using it this way already (and Graphiti's patterns strongly promote this).

Okay, I got it working with strict concurrency, and I added some thread-safety to the unchecked classes. There are 3 unavoidable warnings that hopefully will be addressed by the compiler in the future. Also, I pulled in a few breaking quality-of-life changes, like removing execution strategy arguments, and improving default validation.

I'm going to go ahead and merge this! Thanks for the review!

[NeedleInAJayStack]

This removes the NIO dependency. It is breaking because it removes all Swift NIO-isms that were present in the public APIs (like EventLoopFuture and EventLoopGroup argument/return types).

[NeedleInAJayStack]

Hey @adam-fowler & @paulofaria - I managed to get the tests passing, and I think this is ready for you guys to look again. Could you give it a pass on my changes following your comments?

[NeedleInAJayStack]

@paulofaria Okay, I'm feeling pretty confident in this - do you mind taking a look at the final changes and approving (again)? Thanks for the review!!

[paulofaria]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

Good point - I've poked at it a bit but haven't really figured out the size of the effort. Supporting strict concurrency will be a breaking change, so probably best to do it now if it's feasible. I'll take a look this weekend and see how much work it is. Thanks Paulo!

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

@paulofaria I got almost everything working with strict concurrency checking in this commit (compiling successfully, just 4 tests failing).

That said, I am throwing around unchecked a bit more than I would like. In particular, allowing circular references in the GraphQLSchema type system requires allowing the client to mutate the fields of a GraphQLObjectType, which inherintly makes it non-sendable. Reworking it as an actor is possible, but gives us an async explosion. The cleanest solution is probably to have a "definition" step where types are mutable and not sendable, and an "build" step that converts the entire schema to immutable types. I'm leaning toward just leaving it unchecked and documenting that the schema should not be mutated after starting to execute against it, because 1) it keeps us close to the JS reference implementation and 2) most people are using it this way already (and Graphiti's patterns strongly promote this).

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

@paulofaria I got almost everything working with strict concurrency checking in this commit (compiling successfully, just 4 tests failing).

That said, I am throwing around unchecked a bit more than I would like. In particular, allowing circular references in the GraphQLSchema type system requires allowing the client to mutate the fields of a GraphQLObjectType, which inherintly makes it non-sendable. Reworking it as an actor is possible, but gives us an async explosion. The cleanest solution is probably to have a "definition" step where types are mutable and not sendable, and an "build" step that converts the entire schema to immutable types. I'm leaning toward just leaving it unchecked and documenting that the schema should not be mutated after starting to execute against it, because 1) it keeps us close to the JS reference implementation and 2) most people are using it this way already (and Graphiti's patterns strongly promote this).

Okay, I got it working with strict concurrency, and I added some thread-safety to the unchecked classes. There are 3 unavoidable warnings that hopefully will be addressed by the compiler in the future. Also, I pulled in a few breaking quality-of-life changes, like removing execution strategy arguments, and improving default validation.

I'm going to go ahead and merge this! Thanks for the review!

[NeedleInAJayStack]

This removes the NIO dependency. It is breaking because it removes all Swift NIO-isms that were present in the public APIs (like EventLoopFuture and EventLoopGroup argument/return types).

[NeedleInAJayStack]

Hey @adam-fowler & @paulofaria - I managed to get the tests passing, and I think this is ready for you guys to look again. Could you give it a pass on my changes following your comments?

[NeedleInAJayStack]

@paulofaria Okay, I'm feeling pretty confident in this - do you mind taking a look at the final changes and approving (again)? Thanks for the review!!

[paulofaria]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

Good point - I've poked at it a bit but haven't really figured out the size of the effort. Supporting strict concurrency will be a breaking change, so probably best to do it now if it's feasible. I'll take a look this weekend and see how much work it is. Thanks Paulo!

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

@paulofaria I got almost everything working with strict concurrency checking in this commit (compiling successfully, just 4 tests failing).

That said, I am throwing around unchecked a bit more than I would like. In particular, allowing circular references in the GraphQLSchema type system requires allowing the client to mutate the fields of a GraphQLObjectType, which inherintly makes it non-sendable. Reworking it as an actor is possible, but gives us an async explosion. The cleanest solution is probably to have a "definition" step where types are mutable and not sendable, and an "build" step that converts the entire schema to immutable types. I'm leaning toward just leaving it unchecked and documenting that the schema should not be mutated after starting to execute against it, because 1) it keeps us close to the JS reference implementation and 2) most people are using it this way already (and Graphiti's patterns strongly promote this).

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

@paulofaria I got almost everything working with strict concurrency checking in this commit (compiling successfully, just 4 tests failing).

That said, I am throwing around unchecked a bit more than I would like. In particular, allowing circular references in the GraphQLSchema type system requires allowing the client to mutate the fields of a GraphQLObjectType, which inherintly makes it non-sendable. Reworking it as an actor is possible, but gives us an async explosion. The cleanest solution is probably to have a "definition" step where types are mutable and not sendable, and an "build" step that converts the entire schema to immutable types. I'm leaning toward just leaving it unchecked and documenting that the schema should not be mutated after starting to execute against it, because 1) it keeps us close to the JS reference implementation and 2) most people are using it this way already (and Graphiti's patterns strongly promote this).

Okay, I got it working with strict concurrency, and I added some thread-safety to the unchecked classes. There are 3 unavoidable warnings that hopefully will be addressed by the compiler in the future. Also, I pulled in a few breaking quality-of-life changes, like removing execution strategy arguments, and improving default validation.

I'm going to go ahead and merge this! Thanks for the review!

[NeedleInAJayStack]

This removes the NIO dependency. It is breaking because it removes all Swift NIO-isms that were present in the public APIs (like EventLoopFuture and EventLoopGroup argument/return types).

[NeedleInAJayStack]

Hey @adam-fowler & @paulofaria - I managed to get the tests passing, and I think this is ready for you guys to look again. Could you give it a pass on my changes following your comments?

[NeedleInAJayStack]

@paulofaria Okay, I'm feeling pretty confident in this - do you mind taking a look at the final changes and approving (again)? Thanks for the review!!

[paulofaria]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

Good point - I've poked at it a bit but haven't really figured out the size of the effort. Supporting strict concurrency will be a breaking change, so probably best to do it now if it's feasible. I'll take a look this weekend and see how much work it is. Thanks Paulo!

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

@paulofaria I got almost everything working with strict concurrency checking in this commit (compiling successfully, just 4 tests failing).

That said, I am throwing around unchecked a bit more than I would like. In particular, allowing circular references in the GraphQLSchema type system requires allowing the client to mutate the fields of a GraphQLObjectType, which inherintly makes it non-sendable. Reworking it as an actor is possible, but gives us an async explosion. The cleanest solution is probably to have a "definition" step where types are mutable and not sendable, and an "build" step that converts the entire schema to immutable types. I'm leaning toward just leaving it unchecked and documenting that the schema should not be mutated after starting to execute against it, because 1) it keeps us close to the JS reference implementation and 2) most people are using it this way already (and Graphiti's patterns strongly promote this).

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

@paulofaria I got almost everything working with strict concurrency checking in this commit (compiling successfully, just 4 tests failing).

That said, I am throwing around unchecked a bit more than I would like. In particular, allowing circular references in the GraphQLSchema type system requires allowing the client to mutate the fields of a GraphQLObjectType, which inherintly makes it non-sendable. Reworking it as an actor is possible, but gives us an async explosion. The cleanest solution is probably to have a "definition" step where types are mutable and not sendable, and an "build" step that converts the entire schema to immutable types. I'm leaning toward just leaving it unchecked and documenting that the schema should not be mutated after starting to execute against it, because 1) it keeps us close to the JS reference implementation and 2) most people are using it this way already (and Graphiti's patterns strongly promote this).

Okay, I got it working with strict concurrency, and I added some thread-safety to the unchecked classes. There are 3 unavoidable warnings that hopefully will be addressed by the compiler in the future. Also, I pulled in a few breaking quality-of-life changes, like removing execution strategy arguments, and improving default validation.

I'm going to go ahead and merge this! Thanks for the review!

[NeedleInAJayStack]

This removes the NIO dependency. It is breaking because it removes all Swift NIO-isms that were present in the public APIs (like EventLoopFuture and EventLoopGroup argument/return types).

[NeedleInAJayStack]

Hey @adam-fowler & @paulofaria - I managed to get the tests passing, and I think this is ready for you guys to look again. Could you give it a pass on my changes following your comments?

[NeedleInAJayStack]

@paulofaria Okay, I'm feeling pretty confident in this - do you mind taking a look at the final changes and approving (again)? Thanks for the review!!

[paulofaria]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

Good point - I've poked at it a bit but haven't really figured out the size of the effort. Supporting strict concurrency will be a breaking change, so probably best to do it now if it's feasible. I'll take a look this weekend and see how much work it is. Thanks Paulo!

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

@paulofaria I got almost everything working with strict concurrency checking in this commit (compiling successfully, just 4 tests failing).

That said, I am throwing around unchecked a bit more than I would like. In particular, allowing circular references in the GraphQLSchema type system requires allowing the client to mutate the fields of a GraphQLObjectType, which inherintly makes it non-sendable. Reworking it as an actor is possible, but gives us an async explosion. The cleanest solution is probably to have a "definition" step where types are mutable and not sendable, and an "build" step that converts the entire schema to immutable types. I'm leaning toward just leaving it unchecked and documenting that the schema should not be mutated after starting to execute against it, because 1) it keeps us close to the JS reference implementation and 2) most people are using it this way already (and Graphiti's patterns strongly promote this).

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

@paulofaria I got almost everything working with strict concurrency checking in this commit (compiling successfully, just 4 tests failing).

That said, I am throwing around unchecked a bit more than I would like. In particular, allowing circular references in the GraphQLSchema type system requires allowing the client to mutate the fields of a GraphQLObjectType, which inherintly makes it non-sendable. Reworking it as an actor is possible, but gives us an async explosion. The cleanest solution is probably to have a "definition" step where types are mutable and not sendable, and an "build" step that converts the entire schema to immutable types. I'm leaning toward just leaving it unchecked and documenting that the schema should not be mutated after starting to execute against it, because 1) it keeps us close to the JS reference implementation and 2) most people are using it this way already (and Graphiti's patterns strongly promote this).

Okay, I got it working with strict concurrency, and I added some thread-safety to the unchecked classes. There are 3 unavoidable warnings that hopefully will be addressed by the compiler in the future. Also, I pulled in a few breaking quality-of-life changes, like removing execution strategy arguments, and improving default validation.

I'm going to go ahead and merge this! Thanks for the review!

[NeedleInAJayStack]

This removes the NIO dependency. It is breaking because it removes all Swift NIO-isms that were present in the public APIs (like EventLoopFuture and EventLoopGroup argument/return types).

[NeedleInAJayStack]

Hey @adam-fowler & @paulofaria - I managed to get the tests passing, and I think this is ready for you guys to look again. Could you give it a pass on my changes following your comments?

[NeedleInAJayStack]

@paulofaria Okay, I'm feeling pretty confident in this - do you mind taking a look at the final changes and approving (again)? Thanks for the review!!

[paulofaria]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

Good point - I've poked at it a bit but haven't really figured out the size of the effort. Supporting strict concurrency will be a breaking change, so probably best to do it now if it's feasible. I'll take a look this weekend and see how much work it is. Thanks Paulo!

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

@paulofaria I got almost everything working with strict concurrency checking in this commit (compiling successfully, just 4 tests failing).

That said, I am throwing around unchecked a bit more than I would like. In particular, allowing circular references in the GraphQLSchema type system requires allowing the client to mutate the fields of a GraphQLObjectType, which inherintly makes it non-sendable. Reworking it as an actor is possible, but gives us an async explosion. The cleanest solution is probably to have a "definition" step where types are mutable and not sendable, and an "build" step that converts the entire schema to immutable types. I'm leaning toward just leaving it unchecked and documenting that the schema should not be mutated after starting to execute against it, because 1) it keeps us close to the JS reference implementation and 2) most people are using it this way already (and Graphiti's patterns strongly promote this).

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

@paulofaria I got almost everything working with strict concurrency checking in this commit (compiling successfully, just 4 tests failing).

That said, I am throwing around unchecked a bit more than I would like. In particular, allowing circular references in the GraphQLSchema type system requires allowing the client to mutate the fields of a GraphQLObjectType, which inherintly makes it non-sendable. Reworking it as an actor is possible, but gives us an async explosion. The cleanest solution is probably to have a "definition" step where types are mutable and not sendable, and an "build" step that converts the entire schema to immutable types. I'm leaning toward just leaving it unchecked and documenting that the schema should not be mutated after starting to execute against it, because 1) it keeps us close to the JS reference implementation and 2) most people are using it this way already (and Graphiti's patterns strongly promote this).

Okay, I got it working with strict concurrency, and I added some thread-safety to the unchecked classes. There are 3 unavoidable warnings that hopefully will be addressed by the compiler in the future. Also, I pulled in a few breaking quality-of-life changes, like removing execution strategy arguments, and improving default validation.

I'm going to go ahead and merge this! Thanks for the review!

[NeedleInAJayStack]

This removes the NIO dependency. It is breaking because it removes all Swift NIO-isms that were present in the public APIs (like EventLoopFuture and EventLoopGroup argument/return types).

[NeedleInAJayStack]

Hey @adam-fowler & @paulofaria - I managed to get the tests passing, and I think this is ready for you guys to look again. Could you give it a pass on my changes following your comments?

[NeedleInAJayStack]

@paulofaria Okay, I'm feeling pretty confident in this - do you mind taking a look at the final changes and approving (again)? Thanks for the review!!

[paulofaria]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

Good point - I've poked at it a bit but haven't really figured out the size of the effort. Supporting strict concurrency will be a breaking change, so probably best to do it now if it's feasible. I'll take a look this weekend and see how much work it is. Thanks Paulo!

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

@paulofaria I got almost everything working with strict concurrency checking in this commit (compiling successfully, just 4 tests failing).

That said, I am throwing around unchecked a bit more than I would like. In particular, allowing circular references in the GraphQLSchema type system requires allowing the client to mutate the fields of a GraphQLObjectType, which inherintly makes it non-sendable. Reworking it as an actor is possible, but gives us an async explosion. The cleanest solution is probably to have a "definition" step where types are mutable and not sendable, and an "build" step that converts the entire schema to immutable types. I'm leaning toward just leaving it unchecked and documenting that the schema should not be mutated after starting to execute against it, because 1) it keeps us close to the JS reference implementation and 2) most people are using it this way already (and Graphiti's patterns strongly promote this).

[NeedleInAJayStack]

@NeedleInAJayStack one last question about enabling strict concurrency checking. Have you tried that?

@paulofaria I got almost everything working with strict concurrency checking in this commit (compiling successfully, just 4 tests failing).

That said, I am throwing around unchecked a bit more than I would like. In particular, allowing circular references in the GraphQLSchema type system requires allowing the client to mutate the fields of a GraphQLObjectType, which inherintly makes it non-sendable. Reworking it as an actor is possible, but gives us an async explosion. The cleanest solution is probably to have a "definition" step where types are mutable and not sendable, and an "build" step that converts the entire schema to immutable types. I'm leaning toward just leaving it unchecked and documenting that the schema should not be mutated after starting to execute against it, because 1) it keeps us close to the JS reference implementation and 2) most people are using it this way already (and Graphiti's patterns strongly promote this).

Okay, I got it working with strict concurrency, and I added some thread-safety to the unchecked classes. There are 3 unavoidable warnings that hopefully will be addressed by the compiler in the future. Also, I pulled in a few breaking quality-of-life changes, like removing execution strategy arguments, and improving default validation.

I'm going to go ahead and merge this! Thanks for the review!