08:14 <repo> Blacksmoke16: I started a new pet-project with athena, avram and graphql. I've told you this many times, but once again: kudos for athena. It's so well designed. I love it <3

08:18 <repo> I discovered a major drawback in the graphql shard though (not yours, i know): It's not possible to use a dataloader. Furthermore, i haven't seen any dataloader implementation in crystal... It would seem to be quite straight forward since the good fiber support in crystal. I think the hard part is to make the graphql resolver resolve fields asynchronously.

14:13 <FromGitter> <Blacksmoke16> 💪 thanks dude, glad to hear :)

14:14 <FromGitter> <Blacksmoke16> unfortunately i never used graphql so im not sure what that means xD

15:39 <repo> heh :)

15:40 <repo> well since you have great freedom in what you query (e.g. author { books { publisher { name } } }) you really quickly end up with N+1 queries (like in my example because you will query the publisher for each book instead of all publishers with any of the book ids.

15:44 <repo> this is where dataloaders come into play. They batch the db requests. They usually have a #load(id) method or something similar, which adds the id to a batch. After a "while" (say a millisecond or so) the loader then calls a batch loading function you have to implement for each loader with all ids that have been requested. The #load function waits until the batch loading is done and picks the

15:44 <repo> result from the array of results from the batch loading.

15:46 <FromGitter> <Blacksmoke16> is that something you could make a PR for? :P

15:46 <repo> where?

15:46 <repo> i think a dataloader would have to be an own shards

15:46 <repo> -s

15:46 <FromGitter> <Blacksmoke16> deff sounds like it would be useful. never really thought about N+1 query stuff in graphql tho. makes sense since you dont have control over the queries (or do you?)

15:46 <FromGitter> <Blacksmoke16> oh its not part of graphql itself?

15:46 <repo> no it's not

15:47 <repo> yeah you don't really have control over the queries

15:47 <FromGitter> <Blacksmoke16> ahh gotcha gotcha

15:47 <repo> authorization is also fun :D

15:49 <repo> i could make a pull request which would parallelize the resolving of fields in graphql

15:50 <repo> this would be a prequisite for this to work, because the load(id) calls have to happen in parallel.

15:51 <FromGitter> <Blacksmoke16> by parallel im assuming you mean via fibers? parallel would require the MT flag

15:51 <repo> yeah fibers

15:51 <repo> concurrently :)

15:51 <FromGitter> <Blacksmoke16> afaik if you implement that correctly it should just work when MT becomes the default (or is enabled by the user)

15:51 <FromGitter> <Blacksmoke16> could be a nice win too

15:52 <repo> it should work in any case. doesn't need MT.

15:53 <FromGitter> <Blacksmoke16> could be worth it yea

15:53 <FromGitter> <Blacksmoke16> which shard are you using for it?

15:53 <repo> for graphql?

15:53 <repo> graphql-ruby/graphql

15:53 <FromGitter> <Blacksmoke16> yea

15:53 <repo> sorry

15:53 <repo> graphql-crystal/graphql

15:53 <repo> :D

15:53 <FromGitter> <Blacksmoke16> gg

15:53 <repo> i think, it was that one. :P

15:54 <repo> yeah

15:54 <repo> https://github.com/graphql-crystal/graphql

15:54 <FromGitter> <Blacksmoke16> is also https://github.com/ziprandom/graphql-crystal. idk what they diff between them is tho

15:54 <FromGitter> <Blacksmoke16> looks much older

15:55 <repo> yeah

15:56 <repo> graphql-crystal/graphql seemed more mature

15:56 <repo> https://github.com/graphql-crystal/graphql/blob/main/src/graphql/object_type.cr#L110

15:56 <repo> here the logic would have to change

15:56 <FromGitter> <Blacksmoke16> and btw, if you haven't seen, https://athenaframework.org/Routing/RoutingHandler/ might be helpful if you're really only using the routing features versus DI and all that other stuff

15:56 <FromGitter> <Blacksmoke16> 👍

15:56 <FromGitter> <Blacksmoke16> wew thats a good chunk of macro code

15:56 <repo> yeah i looked at it but i needed DI anyway :)

15:57 <repo> yeah :D

15:57 <FromGitter> <Blacksmoke16> 👍

15:58 <repo> alternatively (maybe that's even easier to do) one could return a Promise (there's a shard for that) and then one would just have to add a case here: https://github.com/graphql-crystal/graphql/blob/main/src/graphql/object_type.cr#L17

15:59 <repo> which could just resolve the promise and call the same method with the result

15:59 <repo> ah no

15:59 <repo> it'd still be sequential

16:01 <FromGitter> <Blacksmoke16> if you just want to run things concurrently would prob have to use fibers/channels

16:02 <FromGitter> <Blacksmoke16> like spawn them all then in some method do like `n.times { yield results.receive }`

16:02 <FromGitter> <Blacksmoke16> or instead of yielding, create an array of each result and return it once they're all done?

16:04 <repo> yeah.

16:07 <FromGitter> <Blacksmoke16> related: https://github.com/crystal-lang/crystal/issues/6468

19:40 <FromGitter> <rjnienaber> is there anything like the using directive (https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/using-directive) from C# in Crystal? I'm trying modulize my classes correctly (e.g. `Amazonite::DynamoDB::AttributeDefinition`) but in practice it starts to get a bit repetitive.

19:43 <FromGitter> <Blacksmoke16> in some (most?) cases you can prob get away with just using `AttributeDefinition`

19:43 <FromGitter> <Blacksmoke16> esp when you're already within a type in he `Amazonite::DynamoDB` namespace

19:44 <yxhuvud> You can also use alias to create a short-form of a longer definition

19:44 <FromGitter> <Blacksmoke16> otherwise you could use private aliases

19:45 <FromGitter> <Blacksmoke16> ^ yea, for some of my stuff i expose some aliases on the top level that can be used to avoid the first two part of the type into a 3 or 4 letter name

19:46 <FromGitter> <Blacksmoke16> related: https://forum.crystal-lang.org/t/project-relative-require/4617/5

19:46 <FromGitter> <Blacksmoke16> the bottom part of that post at least

19:47 <FromGitter> <Blacksmoke16> https://crystal-lang.org/reference/1.6/syntax_and_semantics/alias.html

19:53 <FromGitter> <rjnienaber> that's definitely close to what I'm thinking of. Would it be possible to write a macro that is the equivalent of `private alias ScalarAttributeType = Amazonite::DynamoDB::*` ?

19:54 <FromGitter> <Blacksmoke16> you'd inherently have that already as `private alias ScalarAttributeType = Amazonite::DynamoDB`

19:54 <FromGitter> <Blacksmoke16> `ScalarAttributeType::SomeType.new`

19:57 <FromGitter> <rjnienaber> that's for a single type though, right? In my scenario, there would be a need for many `alias` statements so i'm trying to avoid having 20 lines of declarations at the top of the file. Something more akin to how `require "./core/*"` works, but for bringing in all the types of a namespace

19:57 <FromGitter> <rjnienaber> sorry if i'm incorrectly mixing up terminology

19:58 <FromGitter> <Blacksmoke16> right ⏎ ⏎ ```code paste, see link``` ⏎ ⏎ or are you thinking of something else? [https://gitter.im/crystal-lang/crystal?at=6349bf4b86407c265b72320c]

19:59 <FromGitter> <rjnienaber> At the moment I have this: ⏎ ⏎ ```code paste, see link``` ⏎ ⏎ which works but I can see that list of aliases being a lot longer [https://gitter.im/crystal-lang/crystal?at=6349bf8e27f328266d3c0b13]

20:00 <FromGitter> <Blacksmoke16> id so something like: ⏎ ⏎ ```private alias ADB = Amazonite::DynamoDB ⏎ ⏎ ADB:: ScalarAttributeType ⏎ ADB::KeyType``` [https://gitter.im/crystal-lang/crystal?at=6349bfd15b0dbc04b883750e]

20:01 <FromGitter> <Blacksmoke16> would be the simplest approach id say. doesnt allow you to use each type's name directly, but helps a lot

20:01 <FromGitter> <Blacksmoke16> could prob write some macro to like iterate thru the types to generate the private aliases but :shrug:

20:01 <FromGitter> <rjnienaber> that's perfect!

20:01 <FromGitter> <rjnienaber> thank you :)

20:02 <FromGitter> <Blacksmoke16> 👍 np