explanation
Server-side GraphQL in Node.js is a course on building a GraphQL API on a Node.js server using Apollo Server. GraphQL is an open source query and data manipulation language for application programming interfaces (APIs). GraphQL was first used by Facebook in 2012 and was released to the public in 2015, making it available to other developers. GraphQL has attracted many fans so far because it allows users to define the data structures they need and return the same data structures from the server.
Course Features
In the server-side GraphQL in Node.js course, the first instructor, Mr. Scott Moss introduces GraphQL and explains how GraphQL works on both the user and server sides. He then explains that to create a GraphQL server, you first need to create a template using Template Definition Language (SDL) and review the basic parts of the schema. The following steps show how to build a simple GraphQL server that encodes typeDef, solvent, and Apollo server. The purpose of this section is to show you a simple way to work with GraphQL before going into more detail. The following sections detail issues such as queries, solutions, arguments, input types, jumps, advanced SQL, and more.
Course specifications
- Publisher: Frontend Masters
- Instructor: Scott Moss
- Language: English
- Education level: from basic to advanced
- Number of classes: 6 sections, 28 classes
- Duration: 3 hours 24 minutes
course topic
1. Introduction
introduction
00:00:00 – 00:11:48
Scott Moss defines GraphQL as a declarative query language and explains how GraphQL works on both the client and server sides.
scheme
00:11:49 – 00:14:01
Scott explains that to create a GraphQL server, you first need to create a schema using Schema Definition Language (SDL) and review the basic parts of the schema.
GraphQL server
00:14:02 – 00:26:36
Scott shows how to build a basic GraphQL server by coding a typeDef, resolver, and Apollo server. The goal of this section is to show you a simple way that GraphQL works before going into a more detailed explanation.
2. Query and solver
query type
00:26:37 – 00:33:29
Scott defines query types as object types and shows how to write queries. He also answers audience questions about syntax and query usage.
resolver
00:33:30 – 00:44:58
Scott defines a resolver as a function that returns a value for a field of a type, and explains that creating a server using GraphQL requires a query type with the fields and a resolver for those fields.
Query Type Practice
00:44:59 – 00:52:35
After Scott walks through the code repository and specifies the files to be updated over the course of the workshop, students are instructed to create a query type based on the array.
Query Type Solution
00:52:36 – 01:05:58
Scott live codes solutions to query type exercises.
Solver Q&A
01:05:59 – 01:16:20
Scott explains that each field has its own solver, shows what the default solver is, and answers audience questions about top-level and field-specific solvers.
3.Arguments and input types
take over
01:16:21 – 01:21:28
Scott explains that arguments allow the client to pass variables along with the query, which can then be used to fetch data from the resolver. Arguments must be defined in the schema, but can be added to any field.
input type
01:21:29 – 01:25:06
Scott defines an input type as an argument type and how every field of the input type can be another input type or scholar.
Arguments and input types demo
01:25:07 – 01:30:56
Scott shows you types, how to code input types, how to query types, and how to add arguments to resolvers.
Arguments and input types practice
01:30:57 – 01:37:49
Students are instructed to create an input type, add arguments to the query, and use the arguments in the query field interpreter to filter the data. Scott answers audience questions about queries.
Arguments and Input Types Solution
01:37:50 – 01:48:28
Scott live codes solutions to the Arguments and Input Types exercise.
4. Mutation
mutation type
01:48:29 – 01:57:35
Scott explains that a transformation is a type of schema that defines what a client can do to create, update, or delete data.
mutant movement
01:57:36 – 01:59:43
Students are instructed to define mutation types in the schema, add fields to the mutation type, create input types or mutation field arguments, and create interpreters for the mutation fields.
mutation solution
01:59:44 – 02:08:06
Scott live codes solutions to the mutant movement.
5. Advanced SDL
enumeration
02:08:07 – 02:13:03
Scott explains that an enumeration is a set of individual values that can constrain a field to several different options, and shows how to add an enumeration to a type.
interface
02:13:04 – 02:21:49
Scott explains that if you have more than one type with fields in common, an interface allows the types to share fields and allows clients to make one query instead of multiple queries when looking for a field. An interface can determine all types it belongs to.
Interface Q&A
02:21:50 – 02:27:51
Scott answers audience questions about interfaces and data sources, how to find types, and GraphQL syntax.
Union
02:27:52 – 02:34:31
Scott explains that unions are similar to interfaces in that they provide access to types. However, unlike interfaces, a single query can access types that do not have common fields. Questions from the audience are answered.
relationship
02:34:32 – 02:38:06
Scott explains that in GraphQL, an API is a set of nodes connected to other nodes, defining relationships that add types with field values of other types.
relationship demonstration
02:38:07 – 02:48:42
Scott shows how to use field-level resolvers to create relationships between types.
relationship practice
02:48:43 – 02:51:12
Students are instructed to add a new field to a type that references another type and to create a resolver for the field type that points to the other type.
Relationship Solution: Add Fields to Types
02:51:13 – 02:54:34
Scott first live codes the first part of the solution for the Relationships exercise by adding new fields to the various types.
Relationship Solution: Add Resolver
02:54:35 – 03:07:50
Scott continues to live code a solution to the relationship exercise by adding field resolvers and enabling data querying.
Relationship Q&A
03:07:51 – 03:12:40
Scott answers audience questions about queries in GraphQL, field-level resolvers, and query execution order.
proof
03:12:41 – 03:18:33
Scott shows how to add authentication to your Apollo server and explains that the level of authentication depends on what needs to be protected within the schema. He also talks about request level caching to avoid querying the database every time.
6. Finishing
finish
03:18:34 – 03:24:48
Scott answers questions about concurrency, resolvers, and GraphQL gateways, shares open source projects that use GraphQL (Prisma Hesura, GraphQL Yoga, etc.), and concludes the course.
movie
installation manual
After extracting, watch with your favorite players.
Subtitles: English
Quality: 720p
download link
Download Frontend Master – Server-side GraphQL in Node.js 2019-11
Download Frontend Master – Node.js 2019-11 Server-side GraphQL for children only
File password: www.downloadly.ir
File size:
1GB