[GraphQL Basics course] [Main Task]

[atherdon]

Please start by reading the documentation, related to GraphQL: https://www.howtographql.com/
After reading each chapter - please briefly explain to me here what did you learn from it.
Format(example):

Chapter 1: Intro (https://graphql.org/learn/)

"It's covering the basics of graphql"
Questions: "How i can run it at my local PC"?

---

[Atinuke001]

The advantages of Graphql over Rest, I was able to understand that with Graphql, an API end point with only one request to the server by sending a post request to the server.Graphql has a direct fetching and you do not have to adjust the API when product requirements and design change, faster feedback cycles.it uses strong type system to define the capabilities of an API. The schema type of the Graphql serves as a contract between the client and the server.it uses the SDL(Schema Definition Language) to define the schem.

[Atinuke001]

Chapter 1 : Intro
GraphQL is a new API standard that provides a more efficient, powerful and flexible alternative to REST, and query language used to query the APIs,API defines how a client can load data from a server.A more efficient Alternative to REST,Facebook started using GraphQL in 2012 in their native mobile apps,it has a radip growing community.

Chapter 2: GraphQL is the better REST
GraphQL was developed to cope with the need for more flexibility and efficiency,GraphQL helps us fetch data and not over fetching or under fetching the data, very flexible ,It offers some great ideas, such as stateless servers and structured access to resources.

• Data Fetching with REST vs GraphQL:
  With REST data fetching is across multiple end points while in GraphQL data fetching is from 1 endpoint with only one request to the server b sending a post request to the server.
• Rapid Product Iterations on the Frontend:
  The changes can be made on the client end without plenty work on the server due to the flexibility
• Benefits of a Schema & Type System: it uses its own schema type called SDL(schema definition),the schema serves as the contract between the client and the server to define how a client can access the data.

Chapter 3: Core Concepts
This chapter explains the fundamental language to construct GraphQl,GraphQL has its own type system that’s used to define the schema of an API. The syntax for writing schemas is called Schema Definition Language (SDL). it gives explanation on the root element to the child element, the relationships between two or many schemas, basic query on retrieving all information from the database, GraphQL allows you to query your data based on an argument.

• Writing Data with Mutations: We have 3 kinds of mutations

  • creating new data:
  • updating existing data
  • deleting existing data

• Real-time Updates with Subscriptions: Many applications today is to have a real time connection to the server in order to get immediately informed about important events

• Defining a Schema: Schema is a collection of all GraphQL types, It specifies the capabilities of the API and defines how clients can request the data. It is often seen as a contract between the server and client.The Query, Mutation, and Subscription types are the entry points for the requests sent by the client

• Big Picture (Architecture):
  3 different kinds of architectures that include a GraphQL server:

  • GraphQL server with a connected database: connects directly with any database.
  • GraphQL server is been integrated with a third party application and integrates them through a
    single GraphQL API: it integrates directly with a third party application.
  • A hybrid approach of a connected database and third party application that can all be accessed
    through the same GraphQL API: integrates with the database and also the third party application

• Resolver Functions: The sole purpose of a resolver function is to fetch the data for its field, When the server receives a query, it will call all the functions for the fields that are specified in the query’s payload. It thus resolves the query and is able to retrieve the correct data for each field

• GraphQL Client Libraries:data fetching approach

  • describe data requirements
  • display data in UI

[Atinuke001]

In addition to the link you shared with me , i also finished this online training on graphql from video 1 to video 35 - https://www.youtube.com/watch?v=Y0lDGjwRYKw
Chapter 5: Advanced Tutorial - Clients
Some features in the frontend app

• directly sending queries and mutations without constructing HTTP requests: allows you to fetch and update data in a declarative manner
• view-layer integration: GraphQL clients use the concept of higher-order components to fetch the needed data under the hood and make it available in the props of your components
• caching: GraphQL queries into the store and whenever that exact same query is executed again
• validating and optimizing queries based on the schema: there is a great opportunity to validate and potentially optimize the queries that a client wants to send already at build-time
  Colocating Views and Data Dependencies:A powerful concept of GraphQL is that it allows you to have UI code and data requirements side-by-side

Chapter 6: Server
Implemented on the server side

• GraphQL execution: an actual execution algorithm for how those queries are transformed into results, the query in this chapter The query is cut across field by field, executing the resolvers for each field.
• Batched Resolving:
  Instead of fetching data naively, we could fetch the data,By making our fetching a bit smarter. We can wrap our fetching function in a utility that will wait for all of the resolvers to run, then make sure to only fetch each item once

Chapter 7: More GraphQL Concepts

• Enhancing Re-usability with Fragments:
  A fragment is a collection of fields on a specific type
• Parameterizing Fields with Arguments: Each field in graphql can take zero or more arguments, graphql makes it easy to pass default value for arguments.
• Named Query Results with Aliases: One of the greatest advantage of graphql is the ability to send multiple queries into one request and the response data is been returned based on the fields being requested, naming issue might be a big deal.
• Advanced SDL(Schema Definition Language):
  - Object & Scalar Types: For Scalars we have String,int,Float,Boolean and ID while Objects are user
  or post.
  - Enums: GraphQL allows you to define enumerations types (short enums), allows you express a
  fixed type of values
• Interface: describing a type in an abstract way, in graphql, every type is expected to have an ID field,Using interfaces, this requirement can be expressed by defining an interface with this field and then making sure that all custom types implement it ,Using interfaces, this requirement can be expressed by defining an interface with this field and then making sure that all custom types implement it.
• Union Types: collection of other types when you have two schema you could take the join by join them together.

Chapter 8: Tooling and Ecosystem
The ability for clients to ask a server for information about its schema is called introspection by querying the graphql meta-field which is always the root of the query. it helps you dig to the surface of the schema.

• GraphQL Playground : serves as an interactive tool for query Graphql API also known as "GraphQL IDE", has features for mutations and subscription.

Chapter 9: Security
Timeout: helps the server to know the maximum time allowed for the query to run.
Maximum Query Depth: Knowing your schema and giving you an idea of how deep a legitimate query can go is maximum query depth. Graphql is able to accept or reject query based on its depth
Throttling: APIs uses simple throttle to stop clients from requesting resources too often but throttling on Graphql is special because throttling on a number of request doesn't really help.
- Throttling Based on Server Time : helps to come up with a maximum number of time client can use
over a certain time frame
- Throttling Based on Query Complexity: helps reduce limit on the schema

[atherdon]

awesome - ok, so i think we're ready to start coding part, right?

[Atinuke001]

Yes.. what next

[atherdon]

Ok, so i have a lot of things to read - before we'll start. Did you examine our Readme file?

[Atinuke001]

Hello,
Sorry for my late response, trying to understand the Readme File and the relation types between the data structure.

[atherdon]

dont worry and take your time. and if you need help - ask specific questions and i'll explain