Apollo Federation Setup | Part 1 -- Federation setup

[Music] hey guys and welcome back to another setup tutorial in today's tutorial we're going to be focusing on apollo federation and what we're going to be focusing on today is we're going to be walking through how to uh break up our monolithic apollo server into an apollo federated schema and with this schema we're going to be splitting up that server into multiple different subgraphs and you can think of each subgraph as its own type of microservice that would microservice that will kind of be in charge of its own specific domain and handle its own thing and um this way it's kind of an alternative way to also to schema stitching if you have ever heard of that but it's really useful you kind of create these sub graphs and then you create a gateway that sits in the front and this gateway knows the schema of your entire federated schema so that you can always call the gateway and access all of your resolvers so let's go ahead and get started the first thing we're going to do is that we're going to create a book service project and we're going to use uh the prismacogen apollo server project that i kind of created in the couple videos ago and we're going to be using that because it's pretty much a monolithic apollo server and i've done a couple of changes to it so previously i was only using one uh type but as i got a little bit more familiar i wanted to get used to uh resolving different types within each other and so i've made quite a bit of changes and i'll put a link in the description below to this project as well as a link to the video here um so that you guys can either follow along with that or if you guys want to just grab the starter project to follow along to this video so once you created that we're going to go ahead and we're actually going to open it up so i'm going to cd into it and it should be oh i named it book service and let's go ahead and take a look at what we have here as i mentioned before i made quite a bit of changes to this project um we can quickly go over some of those and some of the changes that i made were for example i'm using a make executable schema as well as uh i define a bunch more type definitions for example i change the typing from oh i need to install the dependencies and once we go while we do that i can kind of talk about this um so as you can see here i'm kind of resolving different types so now i have like this author type and this author type is pretty much just whoever wrote the book and they have an author id they have a username they have a list of books as well so that you can resolve both ways from author and books i have different input types as well as a mutation type and the reason that i'm using this kind of graphql object type for my mutation and query as opposed to in my video i think i just create this mutation object here is that i wanted to be able to kind of create this make executable schema but i want to print that out with my schema as i had it before so previously i had it as query as mutation but as i went ahead and started changing my mutations around as you can see here it's a little bit more defined to use the typescript types before it was just an empty object but here you can see like for example i have the graphql field resolver i have graphql field config and then you have like the arguments and types and things like that and this is also really awesome and using this along with like cogen you can get really good typing and things like that with your backend project the only issue though is that i spent a bunch of time trying to get this to work using this type of code first usually uh graphql field config graphql object types so if you look at this author type so i have graphql object types and things like that to work with apollo federation and i just was not able to get it to work and i'll get uh i'll get into a little bit more detail about that later on in the video cool so we went ahead and we let's just go ahead and reload the window just in case any dependencies need to be reloaded and um so yeah so we installed everything we're ready to go with our project so the first thing we're going to do actually is we're going to go ahead and our and we're going to add apollo federation to this uh project and then with that we're also going to change how we actually create our schema so as i showed you guys here we were doing make executable schema but instead now what we're going to do actually is we're going to uh just build a federated schema and this type defs is going to be kind of giving me this error for a little bit and the reason for that is because i haven't defined it yet but we'll get back to that a little bit later as well and let's do a little bit of cleanup so we have this and the next thing we're going to do is we're actually going to create our gateway so let's go ahead and use our template cli to create similar to book service but this time i'm going to create a gateway project i'm going to cd into gateway and then let's open it up and the first thing i want to do within this project is i'm going to do quite a bit of cleanup on it as this is still set up as my previous uh project um and we don't really necessarily need that for the apollo gateway since this is going to act as pretty much just like as a front end so that all of our front end can kind of call it and then it has it has access to each subgraph so uh to clean this up what we're going to do is uh we don't need prisma since it's not going to talk to a database it's going to talk to each individual subgraph that will talk to a database so we can remove that pretty much we can remove everything um let's yep let's remove that let's remove lib let's remove cogen we'll leave index because this is going to act as our gateway and then also we're going to we're going to leave cogen here and then one thing we're going to add is we're going to add federation is true um i think this is kind of a good config to add in order to kind of just tell hey code jen this is actually a federated schema um we're going to just remove docker compose for now this is not really necessary in this video uh again we can also remove docker file here and then let's go into our package json and clean this up a bit so since we're not going to be using prisma we can get rid of those get rid of that get rid of all the docker scripts um we can let's change this to apollo uh federation gateway um i'll change the description later that doesn't necessarily need to happen right now and then we can also remove prisma and then we can also remove the prisma client and so there we go i think that should be good to go the next thing we're going to want to do as well is that we're going to change our schema file declaration to instead of being that schema.graphql that we were generating every time we started up our server we're going to actually point it to the gateways url that way we can generate the entire schema for our entire backend all at once since it'll be calling the graphql schema being the gateway url and then the next thing we're going to do is we're going to also change uh our environment variables here and since we're no longer talking to our database we're going to add two service urls and you'll see why this is going to be used here in a little bit and similar to that we're going to make sure that those are defined in our environment that example so that if they're not defined we can actually also get rid of our environment test and so now the next thing we got to do is that we got to modify this index.ts file to actually use the new and i actually also need to go ahead and install the dependencies because it doesn't seem like they are installed i am in gateway why oh that's because i have an extra comma there so that'll fail and so there we go yarn install and so while that's installing we can go over what the changes that we're making in to actually generate this new apollo server gateway so what we're doing here is similar to before we're going to go ahead and instead of kind of we're still creating an apollo server but instead of passing a schema to it we're going to pass a gateway and so what are some of the things that you can pass through this gateway the most important thing and at least that we're going to cover in this tutorial is regarding the service list and pretty much what this is is a list of that's pretty much what it says is list of your services right so the list of all of your possible subgraphs and their name and their url so for example since we defined our book service and our author service here you can see in our service list we have books which we're going to give it the url of here it says 4001 slash graphql and then as well as our author service which is going to point to that url and then we're going to go ahead and similar to our we're going to create our apollo server here and then we're going to do uh we're passing in the gateway as opposed to the schema and then we also added a little thing here called listen which pretty much just tells the apollo server which port to listen to all right and now we're ready to kind of go ahead with the next step and the next step that we're going to do is we're going to split up our monolithic book service into two separate subgraphs and the sub graphs are going to be our book service and our author service so how do we do that so the way that we do that the quickest way is we're actually going to go cd into our book service we're going to remove node modules just to make things a little bit faster once we copy things over so let's go ahead and wait for that to finish and once that's done deleting we can then go ahead and let's just copy over our book service into a new author service so that way once we're listings out here you can see that we have our two subgraphs and we have our gateway and let's go ahead and start cleaning some things up so we're going to actually go ahead and first start cleaning up our book service and the way that we're going to do that is we're going to start removing everything that's related to author from this service so first thing we want to do is in our schema here we're going to actually just get rid of author model altogether because as a microservice architecture you want each a specific microservice to kind of talk to its own database and be responsible for its own thing so we're going to do here is we're going to keep track of the author idea of who actually created the book but we're actually going to also we don't need to store any author related information within this book service anymore so we're going to get rid of that all together so we're going to change that up and then what we're going to do is we're also going to go ahead and we can remove the author service since we don't need that we can also go ahead and within our resolver we can let's remove the create author mutation let's create the get all authors query um we can actually also do something crazy and let's uh delete all of our i guess i could do it like this let's delete all of our type definitions and i'll get back to why we're doing that um but yeah let's do that and then once we do that we can go ahead and um go into our author service and do the same thing and similar to our book service we can actually go ahead and start cleaning up our author service a little bit and similar to that we don't actually need the book model anymore because author service is going to be specifically only used for the author uh model type and then we're also going to remove everything from that is related to books um and then i don't know why it does this weird thing that i gotta do that uh delete that permanently sorry about that black screen if you guys saw something weird there um let's remove our book service remove our book service unit test from graphql we're going to remove the create book mutation and we're going to remove the query and we're going to similar as to what we did in our last one we're going to remove all our type definitions and then we should be ready to go and we're going to change mutation inquiry right now it's going to have a couple of errors but we'll get back to that here in a little bit and then we're also going to go ahead and run our yarn install to start installing some of our dependencies and um that way we won't get those red squigglies anymore and uh the next thing we also got to clean up is an index as we did in the gateway we need to specify which port this is going to listen to and so for uh arthur's server we uh actually made it 4002 so we're going to change that up and then if we go to our book service we also need to change that up in here to make sure that the book service is also waiting on port 4001 and then let's remove this bin since we're not going to be using that and then also install these dependencies so let's go ahead and start off by actually implementing our author service sub graph to work in a federation so what are we going to do first so as you've probably noticed before we don't have a typedef's file that is being used in our schema so what we need to do is actually we need to go to define that and while we define that i'm going to explain kind of why i went away from um using the graphql object type and this kind of code for solution and the reason for that and the reason why we got rid of all of my type definitions before is because i couldn't really figure out an easy way for me to use uh that code first solution uh but also include directives so as you can see here we're using this key directive which is part of the federation schema and this directive i wasn't ever able to actually attach it to a graphql object type that i was creating and i'm not entirely sure if that's just because i wasn't really able to kind of figure it out but i played around with it for probably a solid like six hours trying to get this uh key to work and this this directive is extremely important in order to get um the federation to understand that this is an entity meaning that uh this should be able to be resolved within the entire the big picture of things and then another thing i could also figure out is this kind of this extend keyword here which means like we're kind of extending these types to also be included within uh the entire uh federation so i couldn't necessarily figure out how to do that correctly i would try to do like ast nodes extension ast nodes and like all of these different weird uh things their documentation wasn't too clean on it like as to how to actually get it to work so i just say just decided to be like okay whatever let's go the sdl route uh even though i did mention in my previous video that i don't really like having one huge type definition file but in order to get it to federation to work with the least amount of headaches this is kind of what i kind of uh when it comes down to and you can use type graphql in order to kind of do this um so you don't necessarily need this but i've also found that type graphql does a lot of kind of like things behind the scenes in order to get this directive to actually work and it's just a completely different flow of things and i didn't want to mess with that and also because of this kind of this weird integration with these directives you can't necessarily get graphql nexus to work with uh federation either at least from all of the articles and posts that i saw on github and things like that it seems like federation is currently not supported on nexus let's go ahead and kind of go over this type definition file and kind of explain that what's going on here so pretty much what we're doing is that we're creating a query object and within this query we're going to specify all of the queries that belong to this service so the only query that we're going to specify right now is authors which is going to get all of the authors and it's going to return a list of authors we have our mutation which is the create author mutation which is going to take a create author input which is just a username and then it's going to create an author and return that author and then we also have the author type here and then we're going to have an author id for this type and a username and then we also specify this key here which pretty much tells it hey this entity can be uh used uh using this field here to kind of look out for that and um once we define that we can go to schemas and we can see now that the error went away and that's because our type definitions is okay but one thing we do got to clean up is that we actually got to go into our uh mutations and uh the other query that we have and actually cleaned this up a little bit so previously you can see here we were doing kind of a graphql field config and a field resolver but now i'm just going to make it just so it's just a field resolver with the name create author mutation but the other parts are pretty similar so we still have the source the input is going to be the username because that's the create author input that's expected we're going to call the create author from our auth service here which pretty much just takes the username and then it creates it within our prismacontext and then uh returns that and then the next thing we're also going to have to do is within our get all authors query similar to how we just change it up before we just make it a graphql field resolver which is going to go call our author service and which that goes ahead and just gets all of our authors from our database and then what we also got to change up is our mutation now only has create author and then query also now only has a get all authors query and you can still kind of see that we're still able to kind of uh modular modularize it a little bit where we can have our resolvers split up a little bit the only thing is type definitions um you do kind of necessarily need it to all have it within one giant type definition file but that's not the end of the world hopefully if you're using this correctly in a microservice architecture you won't need to have this too big and then if not then your microservice is necessarily too big right so we got that done and then the next thing we got to do is we got to modify our resolvers to include the big buck or the big buck here which is this resolve reference so if you're not familiar with what resolve reference is this is pretty much a a special kind of function that you can define for every single entity and you define an entity by providing this uh key directive here so pretty much what this does is that it's kind of like a way for graphql to be able to kind of tell your gateways query planner to be like hey if you see this actually come to my service to resolve it and then once you try to resolve that what we're going to do is we're going to get author by id and then since we're expecting this to kind of come in as an author type name with the author id as a string we're going to need to parse that out to an int you could probably play around with this later on to make it a uuid or something else but this is kind of just a quick easy tutorial and so once that's done once you see the author and it kind of comes and your federation decides okay i see author i'm going to go to the author service since that's where it's like supposed to be like everything author related is going to be handled within this subgraph how do i resolve this uh subtype right which is the author type i actually go into this resolve reference and then i take the author id and then i get the author by that id and i return that to whatever uh the the query planner is kind of expecting it to go and that's really all that we need to do and why is this not okay it needed the comma and so that's really all we need to do within the author service so that should be ready to go the next service we've got to change up a little bit is let's go to our books service and we're going to open that up and we're going to do something very similar so what we're going to do in here is we're going to create the type definitions and then this one already has a typedesk file or i mean wait i just created that that's why it's there and then this one is a little bit different and it's a little bigger than the author service which is why i kind of left it for second but pretty much what we have here is we have this books as well as this books by author uh query which pretty much just um returns all the books by by author id gets all the books you have this mutation which is just create books similar to the author here you can see our type of book is actually the same thing we're going to specify book as an entity that could be resolved through our federation we have a book id a title and then here you can see we can actually specify just the author and we don't actually need to specify author id within this type so this author we can also extend it so we don't necessarily sense we're going to be um defining uh author's subservice right or a sub graph but that should handle defining the author type so within our type definition anything that any fields that we want so for example username we want to define within this part of the schema but let's say for example we want to use let's say that author type in some another schema what we can do is extend it but we can also add on to that as part of like this federated schema so for example we want to be able to get all of the books for a specific author right and so this is going to uh be handled within the book service because that's the subgraph that is in charge of books but we can extend the author type so that the author type within the author subgraph also is aware that hey this type has a list of books attached to it and for this tutorial i'm going to remove the get all books by author extended from the query here in the book service because we're not going to necessarily define it for this one we're going to use it directly in our resolvers um but let's go ahead and similar to the author service clean this up a little bit so we're going to remove that we're going to change up mutation oh that's not right we're going to change it up to just be something like this we're also going to modify our get all books query and then we're going to modify our query.ts as well and once we've changed those up now with the last important piece is to change up our resolvers and let's go ahead and there's something weird there okay just got to remove that and make sure that that's not there anymore and let's kind of go over what we've changed up here so similar to our author resolvers we have two different interfaces here because we have the book reference and then we also have an author reference and so the author reference is author id as a string book reference we have a book id as well as author id and then uh within our resolvers is going to be a graphql resolver map we pass in our query and our mutation similar to how we did it before but now we actually have two different types of resolver here so pretty much what's happening here is anytime a book is being resolved as in the book type from our author for our list of books right we're going to have two different types so we're going to one we're going to have resolve reference meaning that hey similar to our authors we want to make sure that if book ever needs to be resolved we can go ahead and get booked by id using that book id so that we can actually return whatever book is trying to be kind of resolved from our federation and then the next thing is also if we are within a book type and we have an author that we're trying to resolve what we're going to do is this is the kind of really cool thing that is part of the federation so what you can do here is you since we have author id correct from our book and this is being passed in from uh the fact that we actually have it stored within the database and that's the reason why we need author id within here um but what we could then do is if we would do this return kind of a special object here where we pass in type name author and then author id is that the federation is smart enough to know that hey i see that the type name that you're trying to do is author what is the necessarily the subgraph that handles that and what do i do with this so what it kind of determines it's like okay so i can see that we're not in the author subgraph in order for me to resolve this author object this author field i need to then go to the author service and then it's going to come to this author service right that's also connected to the federation and then it's going to realize like okay how do i resolve uh an author and then as you saw before in our resolvers that's why we decide the define this resolve reference because then it's going to say okay so how do i resolve author i see here that we have an author resolver and then i see that this is part of the special uh federation how to resolve so pick me like pick this resolver and then i get author by id and since we're passing in the author id we can then resolve the full author object using the author id without necessarily needing to store that author within the book service so that's pretty much how the federation works and that's why it's really powerful and it's also really cool and lets you kind of split it up into a micro service style architecture where it kind of figures out like okay i actually need to go to this subgraph to pick this up or this subgraph to resolve this and then last but not least we also have the author so if we want to let's say we have an author and we want to be able to actually go ahead and get all of the books for it and that's kind of from our type definitions here our extended the extended type of author correct so this extended type of author is also similar to our author service but you see here we are actually defining books within this extended type meaning that we actually need to define the resolver for that within the book service not the author service so we define that by doing books and anytime it sees this books field it's going to resolve it by see author here and then author the author id is a little it's cool how this happens is because how graphql figures out that this author id isn't necessarily from the book right because you can see it's not being passed from the book it's being passed from the author object that's also part of the query so it figures out like hey this author id which we in type definitions you can see that we mark it as external meaning we're getting this from somewhere else so this id is then coming from our other part of the query which is trying to which has the author id and then it passes this author id to our book service which then has access to it within this resolver which then we can use to actually resolve books and then return it all to the gateway which is then returns it to the client so really cool really powerful so that's pretty much uh how the resolver system works in a federation and that was a lot of kind of just talking over stuff and so let's actually go ahead and test this out so the first thing we're going to do is i'm actually going to go ahead and within my environment variables i'm going to let's make sure i don't have anything in here oh i don't think i use that password anymore but just in case um let's go ahead and change that up so what i'm going to do is that within my book service i'm going to create its own database called book db and then i'm going to generate a migration for it so that it kind of picks up the new changes and let's see if it asks me a couple of questions here it should ask me yep delete that and let's name it in it okay so that'll generate my book service migration and then let's go to author service and do something similar here so let me just go ahead and change that up to uh use my test database and then we're actually going to test to change this to author's db now that i've changed i can show you guys so here it's pretty much the same thing as before a postgres url prismaprisma and then we're actually going to name its own database authorsdb and let's go ahead and generate a migration for that so that'll create the database and give me the typings that i need and access to uh the context and this is using why is this using book db this should not be using book db um and the reason it was using book db actually is because i'm in the wrong directory so let me go to author service and then generate a migration from here because now it should use authorsdb there we go and then let me see if it asks me to name anything and yep delete everything and let's name it just init for initializer and so now we have our database set up for this sub graph and it's uh going ahead and doing a couple things there we go and let's start it up and then let's also go to our book service and this one should have created so we can go ahead and start this one up and once those are set up we can start our gateway up and you can see here that now we have it listening on 4001 and then we also have our author service on 4002. let's go to gateway and you can see here that i actually need to also install another library called the apollo gateway and i forgot to do that earlier so let's go ahead and actually add that so now we have apollo gateway being added to our project and once that's done we can also go ahead and start up the gateway that looks like it's finished so let's go ahead and start our gateway and then we can start testing and playing around and making sure everything is working as expected so um let's see what happened here okay so we got localhost 4000 and if you can see here so if you're familiar can i make this bigger yeah we can so um here i have a couple of mutations and queries already set up but if you look at the schema here you can see that the gateway actually has access to both subgraph schema meaning we have access to the author type here which you can see is a combination of our author service of the author id and username but it also has books which we define in the book service so it kind of combines all that into a single author type within the gateway schema and then you can see here we also have book which is just the author which is the author type book id and title um we have the create author input create book input we have our access to our two mutations which are create author and create book and a list of authors and list of books so let's go ahead and create an author and the way that we're going to do that is as you can see this is the syntax for is mutation create author we're going to pass an input variable here which is part of our query variables which is expected of this type and then we're actually going to call the create author mutation so let's go ahead and create this as user one and that should there you go you can see it returned with author id one username one let's change this to user two so now we have author id two and user two and you can see that that worked correctly so if i remove that and let's just get a list of authors you can see here that we have two authors that are created and this is coming from our author service database and then what we're gonna do is we're also going to create a couple of books and so we're going to name this uh book one and we're going to let's get rid of this and let's create that with author id so we're going to make sure that this book is created by one of the users we just created and then we're also going to create a second book for that guy and then let's do a third book for our second guy and then if i go to books and then if i go here you should be able to see that i get a list of all the books we just created and now comes the power of the federation so previously as you saw i just deleted if i just put that back you can see that we have this author and so like in one monolithic kind of graphql server you can define these different types and you can call them because it's just similar to how we're referencing it they're all referenced within one giant type definition and one list of resolvers meaning like they all have access to each other and they all know about each other but the cool thing now is that we're doing this within different services so each microservice or each subgraph if you think about it has access to these kind of queries but the front end doesn't need to know about it all the front end needs to do is we're just going to call localhost 4000 graphql and we're going to pass along this query and as you can see here is going to actually be able to figure out and determine okay how do i actually go and grab this stuff so you can see author we get back with author id and username author id and username author id and username for the author that actually created that book even though in our database within our book service we don't have that uh author information so you can see that the subgraphs are talking to each other and another cool thing is you can even keep it going like if you want to get the list of books again you can go books and you can do title and you can do book id and then if you see here we can actually get that back so books is a continuation and then maybe let's see what happens if we do author again if we do author with uh author id and username and so it goes on and you can see we can just keep chaining and chaining it because we have that set up and uh this introduces kind of an introdu interesting little problem called the n plus one problem but before we get into that let's just make sure our uh other part is working and let's just clean this up a little bit and let's just make sure we can actually also get the books as we should we saw that it works but let's just see that we can get it from within this query and let's get a book id and so this should also be able to return that list as well and for this tutorial that's pretty much it so we've pretty much created an apollo federation um kind of entire setup here we have two different sub graphs which each can communicate with each other and each can resolve its own unique parts we have a gateway that can kind of pick up its entire schema and i guess the last thing i can also show you guys is that as we changed it up a little bit before if we go to our book service here and we go to resolvers you can see that it's kind of complaining here with regards so it's missing a return type since we've kind of created this schema on the gateway and we went ahead and in code jan we actually should change up the schema here as well to be http localhost 4000 graphql and let's go ahead and actually add federation is true and then let's just make sure that i did that in the author service as well if i go to cogen and i did not so let's just quickly do that so http uh localhost 4000 slash graphql and let's add federation it's true and then in the book service what we can then do is run our generate and since we have our gateway currently up and running we can generate different types for our schema that we would otherwise not really necessarily have access to but then the cool thing we can do is that since we now have access to our entire graphql schema we can go ahead and actually return a author type here and then if i actually see import it from our generated now we can get rid of that weird uh annoying little squiggly and yeah as i was kind of talking about that's kind of all for at least this part of the tutorial i'm going to make this a two-part uh kind of setup tutorial and the reason for that is because this is kind of like the main part of actually setting up the federation as you can see we have two different subgraphs that communicate with each other two different databases uh in a micro service architecture gateway that's able to kind of reference and talk to both of them just by calling a single endpoint and everything like that the next thing is as i mentioned kind of briefly is that there is a little bit of a thing with graphql called the n plus one problem and i will hope to address that in the next part of this tutorial with regards to kind of setting up data loader and to kind of try to mitigate that and what that problem is as well as setting this up and kind of configuring it to be a little bit more production ready and what i mean by that is that apollo federation actually has a tool called a rover and you can actually kind of change it up and so like right now for example like any time a sub graph schema changes the i would have to restart my gateway because it's not able to kind of figure out like oh i see that something else changed let me quickly update my own schema so then like i would have to restart the gateway in order to pick up those new changes and um it's kind of annoying you can do it locally and that's fine but in production you kind of don't necessarily want that to happen and the way that we can kind of get around that is introducing a kind of this tool called a the rover cli as well as kind of like federated and we'll go over that how to set that up in the next part of this tutorial but yeah i hope that this uh might have been of some use to you guys i know i've done quite a bit of changing around with my first graphql video but i hope that you guys are able to follow along and kind of understand what is happening if you guys have any questions please let me know if i missed anything please let me know as well in the comment section if you guys enjoyed it leave a like and also put a link to this uh the project as well in uh for my github and so that you guys can kind of like copy it down or like follow along with the video and kind of learn for this yourself uh federation is really cool it's a really awesome way to kind of get around the whole schema stitching issue that uh a lot of kind of like legacy graphql servers kind of had to do i know for my work for example we had to kind of create a completely different uh application to kind of do the schema stitching for us so this is really cool and it's really cool that apollo kind of did that for us it is kind of unfortunate that you have to go the sdl route if you're kind of trying to keep it code first but it's not that big of a deal especially since it's micro service architecture hopefully your type definitions isn't going crazy um but yeah um hopefully this is some help to you guys if you guys enjoyed the video please leave a like and subscribe as well for more content and i hope to see you guys in part two [Music] thanks you

Channel: Leo Roese

Views: 557

Rating: 4.6799998 out of 5

Keywords: apollo, apollo-server, apollo server, apollo federation, apollo gateway, apollo/federation, apollo/gateway, apollo-federation, apollo-gateway, graphql, gql, graphql server, graphql.js, sdl

Id: 8KK1Dwy36uw

Length: 36min 29sec (2189 seconds)

Published: Sat Jun 26 2021