Aprenda a desenvolver um servidor (API) de backend que usa GraphQL como middleware para enviar dados em formato JSON. Neste curso, usamos o Express com o Express GraphQL. Para schemas, usamos o pacote graphql.

GraphQL com Express (Servidor Backend API JSON)

Aprenda GraphQL com Express (Servidor Backend API JSON)

Os Problemas de API REST que o GraphQL quer Resolver (Curso Tutorial)

```markdown
# Resumo do Curso de GraphQL

## Introdução ao GraphQL

No curso, vamos aprender sobre GraphQL do lado do servidor (back-end). Para entender o GraphQL, é importante primeiro conhecer as APIs, especialmente o estilo REST.

## APIs e REST

- As APIs normalmente servem dados em formato JSON e utilizam o método REST.
- Em REST, você possui vários endpoints para obter dados, utilizando os métodos HTTP:
  - `GET /companhias`: Obtém todas as companhias (indice).
  - `GET /companhias/{ID}`: Obtém uma única companhia (show).
  - `POST /companhias`: Cria uma nova companhia.
  - `PUT /companhias/{ID}` ou `PATCH /companhias/{ID}`: Atualiza uma companhia existente.
  - `DELETE /companhias/{ID}`: Deleta uma companhia.

## Problemas do REST

1. **Excesso de Dados**:
   - Muitas vezes, você obtém mais informações do que realmente precisa, resultando em desperdício de bandwidth.

2. **Múltiplos Pedidos**:
   - Se você precisa de dados de várias companhias, pode ser necessário fazer vários pedidos, o que é ineficiente.

3. **URLs Longas e Aninhadas**:
   - Quando há relacionamentos complexos (ex: companhias com produtos e modelos), as URLs se tornam muito longas e difíceis de gerenciar.

## Solução com GraphQL

O GraphQL visa resolver os problemas apresentados pelo REST, oferecendo uma maneira mais eficiente de obter e manipular dados, reduzindo o número de pedidos e a quantidade de dados desnecessários transferidos.

Nas próximas aulas, iremos aprender como implementar e utilizar o GraphQL.

Até a próxima!
```

Olá pessoal, neste curso nós vamos falar de GraphQL.
Então, a gente vai aprender GraphQL do lado do servidor, do back-end, tá certo?
A gente vai aprender como fazer este negócio de GraphQL.
Então, o que é que é o GraphQL?
Para a gente entender isso, primeiro a gente tem que falar de API's, de REST.
Então, vamos aqui no editor de texto primeiro aqui.
Deixa eu ir no terminal, abri o editor de texto.
Então, você vai ter que ter um, o conhecimento básico de API's,
normalmente que servem dados em formato JSON, tem aquele negócio chamado REST.
Então, a maneira REST você tem vários chamados endpoints, né?
Pontos para você obter os dados.
Por exemplo, se eu tiver um modelo chamado companhia, tá?
Para representar uma companhia, a gente tem o get barra companhias,
que é para obter todas as, os dados das companhias, né?
Chamado de index, normalmente.
Aí, se você quiser pegar os dados de uma só companhia,
você vai pegar, vai fazer um pedido para o get barra companhia,
barra o ID da companhia, né?
O ID.
Esse é o chamado show, né?
E tem também o, para poder criar uma companhia, você vai post,
barra companhias, se quiser atualizar, é put, barra companhias,
barra ID ou o patch.
Barra ID, se quiser bela, tá delete.
Barra ID, né?
Barra o ID.
Então, essa é a maneira rest de você nomear, né?
À suas, os seus endpoints, né?
Se você quiser acessar o recurso, o recurso aqui é chamado companhia.
Todas as companhias, dá o verbo get, de HTTP, seguido de barra companhias,
para acessar dados de uma companhia específica, verbo get,
combinar de companhia, barra o ID da companhia,
para criar uma companhia da oposto, barra companhias,
para atualizar da oposto ou o patch, barra companhias, barra o ID da companhia,
para dela estar finalmente, barra companhias, barra o ID da companhia.
Então, tem esse negócio rest.
Você note que tem um, dois, três, quatro, cinco, cinco endpoints,
cinco pontos que você tem que atingir, para poder obter,
fazer a operação que você quiser, né?
Normalmente, quando você dá o get companhias,
ele vai retornar, por exemplo,
se cada companhia é representada por um objeto assim, com o ID, um, dois, três,
e o nome da companhia, sei lá, é por...
E se você falar get barra companhias,
você vai pegar, por exemplo, vai retornar da API uma lista com várias...
JavaScript, com vários objetos assim,
seis, quatro, cinco, assim por diante.
Companhia, minha companhia.
Então, normalmente, não tem só o ID nome,
normalmente, quando a gente lidar com esses APIs, tem vários,
muito mais propriedades aqui.
Tem várias propriedades, não só duas, nesse caso, tem várias.
E às vezes, a gente nem usa essas propriedades,
a gente faz o pedido e termina não usando todas as propriedades,
sei lá, se você está fazendo um índice,
você vai querer o ID e o nome, aí nem usa as outras.
Então, é uma perca de bandwidth, né?
Uma perca de banda,
você gasta tanta banda para obter essas informações
e, no final, nem usa informação.
Então, esse é um problema, né?
E outro problema também que se eu quiser, sei lá,
se eu quiser obter informações de certa companhia,
companhias, companhia 1 e 2 e 3, mas eu não quero todos.
Então, eu vou ter que fazer três pedidos, get,
acompanhar barro ID 1 e ID 2 e ID 3, então vai ser...
Se você tivesse uma 100, ia ser 100 pedidos.
Então, muito, muito, muito pedidos, certo?
Aí tem também outro problema que é o de...
O que acontece se você tiver, por exemplo, se a companhia
tivesse vários produtos e cada produto tem vários modelos, né?
Se você tivesse essa relação, a companhia tem vários produtos,
o produto tem vários modelos.
Aí, como é que faz o rest?
Vai ser para obter, sei lá, barra companhias, por exemplo.
Barra o ID, companhia ID, barra produto,
barra produto ID, barra modelo, barra modelo, ID.
Como é que faz como um negócio fica tão nested, né?
Fica tão um negócio.
Tem vários, vai ficando para baixo, para baixo, né?
Vai descendo de companhia para produto, para modelo.
Aí, o URL do endpoint fica longa e tem várias coisas.
Mas é claro que há maneiras de você resolver esse problema,
mas olhando assim no método rest,
essa é a maneira rest de você fazer o URL aqui
para localizar o recurso até o modelo
que corresponde ao produto, que corresponde ao certo companhia.
Então, esse modelo pertence ao produto especificado,
que pertence ao companhia especificado.
Então, também, o URL fica muito longa.
Então, esses são um dos problemas que o GraphQL quer resolver.
Então, tem o problema de você receber muito informação e nem usar.
E, às vezes, também, tem o outro problema de você receber pouca informação
e ainda precisar demais.
Por isso, você vai ter que fazer mais pedidos para poder obter
todas as informações necessárias.
E, nesse vai e vem de fazer mais pedidos,
você vai ter que...
Você nem vai usar todos os dados.
Então, quando você tem um celular, por exemplo,
e você está no local que a internet, a conexão,
não é muito boa,
você vai baixar os dados e tem muitos dados para baixar e vai ficar lento.
Se você pegar e cortar, tirar todos os dados que não precisa,
vai diminuir o tamanho daquela coisa que você tem que baixar
e vai ficar mais rápido para o usuário,
ainda que ele esteja no local de conexão péssima.
Então, por isso, é uma das coisas que o GraphQL quer resolver.
E já falamos também de vários pedidos.
Às vezes, tem muitos pedidos.
A gente não quer tanto pedidos,
eu quero fazer um de uma vez e tem o problema da URL
que fica muito longo assim, tá?
Então, agora que a gente vai entender o que é que o GraphQL quer resolver,
que tem esses problemas no resto,
a gente vai aprender na próxima aula
como é que a gente vai fazer isso tudo, tá bom?
Então, até a próxima.


000f-01 Os Problemas de API REST que o GraphQL quer Resolver (Curso Tutorial)

Sobre o GraphQL (Aula Tutorial)

# Resumo sobre GraphQL

Nesta aula, foi abordado o conceito de GraphQL e como ele funciona para estruturar e compartilhar dados entre cliente e servidor.

## Estrutura do GraphQL
- **Definição de Modelos**: No GraphQL, os dados são organizados em tipos (por exemplo, `projeto` com atributos como `nome`, `tagline` e uma lista de `contribuintes`).
- **Query**: Uma das palavras-chave principais em GraphQL, permitindo que o cliente solicite exatamente as informações desejadas. Por exemplo:
  ```graphql
  query {
    projeto(nome: "GraphQL") {
      tagline
    }
  }
  ```
- **Resposta**: A resposta vem em formato JSON, contendo apenas as informações solicitadas, o que reduz a quantidade de dados transferida e melhora a eficiência.

## Funcionamento do GraphQL
- **Ponto Único de Acesso**: GraphQL funciona através de um único endpoint (ex.: `/graphql`) onde todas as requisições (leitura, criação, atualização, deleção) são realizadas. Isso contrasta com APIs REST que normalmente têm múltiplos endpoints.
- **Intermediário**: O GraphQL pode agir como intermediário entre o cliente e várias fontes de dados (outros APIs ou bancos de dados), reunindo e enviando apenas os dados requisitados.

## Exemplos de Queries
- O usuário pode solicitar somente os dados necessários. Por exemplo, ao requisitar informações sobre um herói, pode-se especificar quais atributos (como `nome`, `altura`, etc.) são desejados:
  ```graphql
  query {
    heroi {
      nome
      altura
      massa
    }
  }
  ```

## Benefícios do GraphQL
- **Eficiência e Velocidade**: O uso do GraphQL pode acelerar o carregamento de dados, especialmente em condições de conectividade lenta.
- **Flexibilidade**: Os desenvolvedores podem pedir exatamente os dados que precisam, evitando transferências de informações desnecessárias.

## Ferramenta GraphiQL
- O curso irá usar uma ferramenta chamada GraphiQL para realizar testes de queries, focando no desenvolvimento do servidor GraphQL.

## Considerações Finais
- Recomenda-se explorar a documentação no site do GraphQL (graphql.org) para mais informações e contextos de uso. 

> Para a próxima aula, prepare-se para aprofundar mais no desenvolvimento com GraphQL.

estamos de volta estou aqui no site do GraphQL você pode ir em graphql.org
então no GraphQL a gente vai ter que dizer o GraphQL como é que os nossos dados
são estruturados por isso que tem que dizer aqui descreva e seus dados a gente
vai ter que dizer o GraphQL primeiro como é que os dados estruturados é
aí do do lado do cliente tá nós vamos fazer esse curso a focar no servidor
mas do lado do cliente você pede a informação que você quiser nesse caso
tem um tipo que de dado chamado modelo projeto que tem o nome e tagline os
contribuintes contribuintes é uma lista de usuários o nome e tagline são apenas
strings aí você pode fazer uma query essa palavra chave query vai ouvir muito no
GraphQL a palavra query
ah query
então você pede que a informação que você quiser por exemplo esse eu quero
eu quero informação sobre o projeto cujo nome é GraphQL e eu quero só a tagline
não me importa pelo nome eu não me importa pelos contribuintes eu só quero
a tagline desse projeto cujo nome é GraphQL ele vai você vai obter essa
resposta aqui em Jason um projeto que tem tagline a query language for IPS
né esse negócio aqui então essa essa é a que a gente vai ficar fazendo no
GraphQL você pedir os dados que você quiser vai descrever na sua query aquilo
que você quiser exatamente eu quero esse esse tipo de dado nesse modelo
somente isso eu não quero nada mais e o GraphQL vai te mandar só aquilo então
fica muito a não vai precisar mandar todos todas as propriedades do modelo
pro cliente dessa maneira a a banda diminui pro usuário e o usuário vai
vai receber aquilo rapidamente porque o tamanho é menor
então aqui query language linguagem de query essa é a palavra chave query para
o API que é legal sobre GraphQL é que do lado da parte do servidor você pode
ter vários tipos de modelos né companhia tem vários companhia tem vários
produtos e cada produto em vários modelos então esses recursos não precisa
ser centralizado em uma só em um só banco de dados você pode até chamar
outras API para poder obter as informações o GraphQL só vai agir como o
intermediário assim então a gente vai fazer o seguinte você vai do cliente
vai chamar o servidor no endpoint do GraphQL aí o GraphQL pega a tá certo
você quer essa informação tá certo eu vou ver aqui como é que você para achar
essa informação então se eu quiser a informação desse modelo a
ok você tem que dizer o GraphQL como é que você vai obter as informações
para o modelo a aí você faz o pedido e pega o modelo a do servidor né parte do
servidor aí tem também informações que envolve modelo b aí o GraphQL você tem
que dizer e GraphQL para você obter informações sobre o modelo b você tem
que fazer esse pedido aqui para essa API por exemplo aí ele faz pedir obter
informações combina com o modelo informação modelo a pega aquele tudo em
brulho e manda para o cliente tá é isso que o GraphQL vai fazer então não
precisa centralizar todos os dados você pode ter o GraphQL rodando no servidor e
você pode fazer pedido para várias API de qualquer lugar ou até a banco de dados
local tá
e tá aqui demonstrando mais uma vez que você pode pedir por exemplo eu quero o
hero né o herói modelo herói me deu nome me dê a altura e me dê a massa e ele
vai te dar resposta do GraphQL nome é look aí se você quiser mais dados a
altura é mais dados massa 77
e é bom então aqui é muito importante que é muito importante
você pode obter vários recursos em um só pedido é importante o GraphQL você
tem que entender que no GraphQL só tem um endpoint só tem um endpoint tá
deixa eu escrever esse negócio aqui a gente já viu aqui que no resto tem
um endpoint tem um dois dois quatro cinco só para fazer esse negócio aqui da
companhia né mas no GraphQL só vai ter um o GraphQL só vai ter um endpoint a
gente vai chamar de barra GraphQL pode ser qualquer coisa que você quiser
vou chamar de barra GraphQL então tudo vai ser voltado a esse endpoint que todos
os pedidos você vai pedir para o barra GraphQL tá certo barra GraphQL vai ser o
único endpoint que você vai fazer tudo vai ler dados vai criar dados vai
atualizar dados vai deletar tudo lá centralizado no único endpoint então
importante isso tá dizendo aqui a tipo a rest api típica requer e vários o RL
mas o GraphQL pode fazer só um tá
aplicativos usando GraphQL pode ser rápidos até quando você tem conexões
de celular que são devagar são muito lentas tá
ele ilustrou aqui o celular e o anúvem né o GraphQL pode rodar aqui e você vai
pedir do celular vai para o GraphQL o GraphQL sabe você descreva com como
a da a os dados são estruturados e como obter os dados ele pega servidor ABC
pega tudo em brulho e manda de volta para o cliente só aqueles dados que são
necessários que o cliente pediu
tá então tá aqui olha aqui tá descrevendo né tá dizendo que as apis de
GraphQL são organizadas em termos dos tipos e campos não é endpoint tem nada de
endpoint só tem um a gente não se importa muito com isso a gente só se importa
sobre tipo de dados e os campos de cada tipo tá
o notebook tem o tipo query tem um cara o character né tem um planeta espécies
você está descrevendo o tipo né a estrutura de cada tipo de cada recurso
por exemplo esse é o que tem o nome tem vários amigos né friends que é uma
lista de caras tem o planeta o mundo natal né planet tipo planet planeta
natal espécie tem tipo espécie sim por diante
tá aí você pode fazer o pedido eu quero esse herói com o quero o nome do
herói eu quero os amigos do herói mas dos amigos só me dê o nome dos amigos
o planeta natal e se você me dá o planeta natal eu quero saber o nome e o
clima e quero a espécie de dos amigos de cada amigo mas eu quero só saber do
nome do laxfm e da origem e da origem só quero saber do nome
você pode dizer exatamente o dado que você quer que vai precisar no
front end
esse aqui tá falando do grafico o graf e que ele quer que é uma ferramenta que a
gente vai usar para poder fazer pedidos queries do graf real para o servidor
porque a gente vai focar nesse curso na parte do servidor de graf real aí do
que a gente vai usar o cliente chamado grafico para a gente poder fazer essas
queries para testar tá tá bom e dizendo que evolua sua pi sem versões
traga seu próprio código da propriedades de código não sei o que
tá bom quem tá usando graf real e esse negócio então eu recomendo você olhar
essa página graf real o graf que ele ponto o orn tá bom então por essa aula só e até a próxima


000f-02 Sobre o GraphQL (Aula Tutorial)

Gerando o Projeto (servidor Express) [GraphQL]

# Resumo da Aula sobre GraphQL

Nesta aula, iniciamos o desenvolvimento com GraphQL. Aqui estão os passos principais abordados:

## Pré-requisitos

- **Ambiente**: Node.js (versão 10) e NPM (versão 6.4.1).
- **Servidor**: Usaremos o Express para criar um servidor.

## Criando o Projeto

1. **Gerar um Projeto NPM**:
    - Usamos o comando `npm init` para criar um `package.json`.
    - Nome do projeto: `companhia-graphql`.

2. **Instalar Pacotes Necessários**:
    - **Express**: Para criar o servidor.
    - **Express-GraphQL**: Middleware para integração com GraphQL.
    - **GraphQL**: Para definição de tipos e esquemas.

   Comandos para instalação:
   ```bash
   npm install express express-graphql graphql
   ```

3. **Estrutura do Projeto**:
    - Criar o arquivo `index.js` onde o servidor será configurado.

## Configurando o Servidor Express

1. **Código do Servidor**:
   - Importação do Express:
     ```javascript
     const express = require('express');
     ```
   - Criação do aplicativo Express:
     ```javascript
     const app = express();
     ```
   - Definir a porta do servidor:
     ```javascript
     const PORT = 3000;
     app.listen(PORT, () => console.log(`Servidor rodando na porta ${PORT}`));
     ```

2. **Execução do Servidor**:
   - Para iniciar o servidor, usamos o comando:
   ```bash
   node index.js
   ```
   - Acesse `http://localhost:3000` no navegador para verificar se o servidor está rodando.

## Recapitulação

Na aula, você aprendeu a:
- Criar um novo projeto NPM.
- Instalar os pacotes necessários para Express e GraphQL.
- Configurar um servidor Express básico com a porta 3000.

E assim concluímos a introdução ao desenvolvimento com GraphQL. Até a próxima aula!

Estamos de volta, vamos começar e ir para o início do nosso desenvolvimento
para aprender GraphQL.
Então você vai precisar primeiro de Node, tá?
Eu estou aqui no meu terminal.
Eu estou usando Node versão 10, com NPM versão 6.4.1.
Então vai precisar do Node porque a gente vai criar um servidor de Express, tá bom?
Vamos descer o nosso backend para poder rodar o GraphQL como o middleware.
Então vamos precisar dos seguintes pacores, tá?
Vamos primeiro fazer um projeto aqui.
Eu vou gerar um projeto de NPM, vou fazer MQ, DRI para criar um direitório.
Vou chamar, sei lá, vamos ver.
A gente vai falar muito de companhia, produto e modelo.
Vamos chamar esse de companhia, traço GraphQL, tá?
Eu vou dar o CD para entrar no direitório.
Eu estou aqui no direitório companhia GraphQL, vou dar NPM e NET para iniciar um pacote package VJSUN.
Eu vou dar o nome, mesmo nome.
Descrição, descrição, entry point index, com modo de teste, nada.
Gateway repository, nada, keywords nada, auto, botar meu nome.
Licença, botar MIT.
Agora a gente tem um package de JSUN aqui.
Vou abrir esse cara no caten.
Deixa eu abrir aqui, dá para ver.
Tá aqui.
Então o package de JSUN criou, criado aqui.
Tem nada ainda, vamos adicionar um DPNS-PS Projeto.
Vamos instalar o seguinte, vamos instalar, entrem e install.
Primeiro, primeiro o Express, que a gente vai fazer o servidor de Express.
Depois disso, vai instalar o Express GraphQL, que vai ser o Metalware, que a gente vai precisar para rodar o GraphQL no servidor de Express.
E vai precisar do próprio GraphQL para fazer os tipos e esquemas.
Expresso, back end, servidor de web, framework, que a gente vai usar para fazer o back end.
Express GraphQL Metalware, a maneira que a gente vai usar o GraphQL, vai ser via um Metalware de Express.
Metalware.
E vai usar o GraphQL para poder fazer os esquemas, esquema, né?
Então já instalei esses caras, dá uma olhada lá no package.json, tem nas dependências o Express, versão 4.16.4, tá certo?
Pro Express GraphQL 0.7.1, pro GraphQL, versão 14.0.2.
Com isso a gente vai criar primeiro aqui no projeto um arquivo chamado index.js, que vai ser o servidor.
Primeiro a gente dá o require to Express, opa, yeah, faz a variável Express e dá um require do package Express, tá bom?
Agora vamos fazer o seguinte, vamos criar uma variável chamada app, app, e vou chamar o Express para poder obter o app do Express.
Chamo a função assim.
Aí depois disso, eu faço app.less, tá?
Aí você tem que dizer qual a porta, vamos dizer, vou botar 3 mil.
3 mil e ponho callback aqui para mandar um console log dizendo que o app está rodando, servidor.
Servidor rodando na porta 3 mil.
Você pode botar 3 mil numa variável, se quiser.
Vou botar aqui port, 3 mil.
Em vez de falar 3 mil aqui, põe port.
Aí aqui eu posso usar o back tick para poder fazer a interpolação de stream, port.
Vamos ver se funciona esse cara.
Salvar, aí vamos aqui no terminal.
I find node, index.js.
Tá o servidor rodando na porta 3 mil.
Vamos lá no navegador aqui.
Vou abrir o novo tab, localhost, 3 mil.
Tá funcionando porque falou que é not yet barra, tá?
Tá funcionando direto. Se não estivesse rodando, se eu matar o servidor com o control c e atualizar, não vai dar em nada, tá?
Então tá funcionando mesmo.
Volta no editor de aqui, vou te mostrar aqui.
Que a gente fez um servidor bem básico de express.
Então vamos recapitular o que a gente fez.
A gente, primeiro, criou um projeto de NPM, criamos o package.json com NPM init.
Depois disso a gente instalou os pacotes necessários.
Primeiro o express, a gente vai precisar fazer um servidor de express.
Depois o express traça o GraphQL, que é o middleware de express, para poder rodar o GraphQL.
E o GraphQL, próprio GraphQL, que vai nos permitir usar os tipos e esquemas, essas coisas.
Aí vamos, criamos o arquivo index.js, que vai ser o app.
Criamos o app de express, porta 3 mil, falamos app.lesson e o servidor agora roda nessa porta para rodar essa dznode index.js.
E você pode matar o servidor contra o ser.
Tá? Então por essa aula é só e até a próxima.


000f-03 Gerando o Projeto (servidor Express) [GraphQL]

Configurando o middleware Express GraphQL

```markdown
# Resumo da Aula

Nesta aula, o foco é a configuração do middleware do Express GraphQL e a definição do esquema para um aplicativo de servidor.

## Estrutura do Esquema

- **Recursos Principais:**
  - **Companhia**
    - Cada companhia pode ter vários produtos.
    - Cada produto pode ter vários modelos.

- **Estrutura de Dados da Companhia:**
  - `id`: Número inteiro (ex: 1)
  - `nome`: String (ex: "Jevas")

## Implementação no Código

1. **Configuração do Middleware:**
   - Importar o middleware do GraphQL no arquivo `index.js`.
   - Utilizar o endpoint `/graphql` para as requisições.

2. **Importação no Código:**
   - Usar `const graphqlHTTP` para importar o middleware.
   - Configurar o uso do GraphQL HTTP com opções que incluem o esquema (ainda a definir) e a ferramenta do cliente GraphQL para testar as queries.

3. **Criação do Arquivo de Esquema:**
   - Criar um novo arquivo chamado `esquema.js` onde será definido o esquema.
   - Importar o esquema no `index.js` para integrá-lo no aplicativo.

## Conclusão

A definição do esquema será feita na próxima aula, onde se dará continuidade à implementação.
```

pessoal, na esta aula nós vamos, deixa eu rodar o servidor novamente, vamos falar do
esquema, vamos ver como é que a gente vai configurar o middleware express graphql e a gente vai
falar do esquema, do esquema que a gente vai fazer aqui, então vamos lá para o editor
de texto, então a gente, vou fazer esse aplicativo servidor e vai usar o seguinte dados, primeiro
recurso chamado companhia, cada companhia vai ter vários produtos e cada produto vai
ter vários modelos, esse é o esquema aqui, relação entre esses recursos, agora para
a companhia, vamos usar a seguinte estrutura de dados, vamos usar o id da companhia, pode ser só um
e número inteiro e o nome da companhia, por exemplo, a jevas, então vamos começar bem simples
dessa maneira aqui, companhia é um recurso, o modelo que tem propriedade id que é um número
inteiro, tem o nome que é um stream, caracteres, com isso vamos continuar aqui de volta para o index.js
antes de app lesson e depois de app import, vamos colocar o seguinte, vamos aplicar o middleware,
vamos falar app.use, a gente vai ter que usar o middleware do graphql, então a gente vai ter que
importar primeiro, lá em cima, dá o const, chama variável chamada, vamos chamar de graphql,
HTTP, HTTP que é a convenção de nome que eles usam na documentação, mas já vi outros nomes
sendo usados como o próprio graph express, graphql, você escolhe aí express, graphql requer esse
cara e põe nessa variável graphql, HTTP, aí você pega, dá o use, primeiro vai dizer qual o endpoint
que ele vai ficar ouvindo, graphql que a gente vai usar, esse endpoint, você vai fazer o pedido
para o barra graphql, aí o segundo argumento vai ser você chama o graphql, HTTP com um objeto
como argumento, esse objeto vai ser as opções, primeiro vai dar o esquema, a gente ainda não tem
o que então, deixa assim, já já a gente define, o segundo é a gente quer usar o graphql, esse
que é o cliente, a gente poder testar nossos queries, então a gente vai usar o graphql,
você já tinha visto lá o vídeo anterior, lá na página do graphql, vamos usar essa ferramenta
para testar o graphql, tá bom, agora para o esquema, vamos fazer o esquema de graphql aqui,
a gente vai para a gente vai no esquema, para fazer isso vou botar no arquivo exterior, vou criar
arquivo chamado esquema.js aqui, tá bom, aí vou importar esse cara lá do index, vou dizer
esquema e vou importar aqui em cima, vou falar const schema, requer o ponto esquema,
eu não preciso dizer para o JTS, só falar assim, dá certo, e a gente vai definir esse cara na
próxima aula, tá certo, então até lá.


000f-04 Configurando o middleware Express GraphQL

Fazendo a Root Query e Abrindo o GraphiQL (Primeiros Passos no GraphQL)

# Resumo do Transcript sobre GraphQL

Neste transcript, o autor está explicando como criar um schema básico utilizando GraphQL. Aqui estão os principais pontos abordados:

1. **Introdução ao Schema**:
   - O autor menciona que irá criar a raiz do schema de GraphQL no arquivo `schema.js`.

2. **Definição do Schema**:
   - O schema é exportado usando `module.exports` e é criado utilizando `new GraphQLSchema`.
   - Ao criar a `Query`, o autor define um `GraphQLObjectType` com o nome `RootQueryType`, que terá um campo chamado `company`.

3. **Definição da Query**:
   - O campo `company` é definido como do tipo `GraphQLString` e um resolver é fornecido para retornar o nome da empresa.

4. **Importação de Dependências**:
   - O autor destaca a importância de importar os tipos necessários do GraphQL, como `GraphQLSchema`, `GraphQLObjectType`, e `GraphQLString`.

5. **Execução do Servidor**:
   - O autor lembra que é necessário reiniciar o servidor após alterações no código e sugere o uso do `NodeMod` para facilitar esse processo.

6. **Instalação do NodeMod**:
   - O `NodeMod` é instalado para reinicializar automaticamente o servidor ao fazer mudanças no código.
   - Novos scripts são adicionados ao `package.json` para usar `npm start` e `npm run dev`.

7. **Teste da Query no Navegador**:
   - O autor indica que, após configurar tudo, é possível testar a query no navegador acessando `localhost:3000/graphql`.
   - Ele executa a query para obter o nome da companhia e verifica os resultados.

8. **Próximos Passos**:
   - O autor conclui o tutorial mencionando que explorará mais na próxima aula.

---

Esse resumo fornece uma visão geral clara e concisa das etapas e considerações no processo de criação de um schema simples com GraphQL.

estamos em volta então vamos fazer nossa schema primeiro schema root a raiz do
schema de GraphQL aqui vamos lá no atom no editor de texto já temos o middle air
funcionando agora é hora de definir esse esquema aqui
esquema aqui vamos lá no arquivo schema.js e a fazer o seguinte
vamos fazer module.exports vai ser o novo esquema aqui como é que a gente faz o
esquema de GraphQL fala new graphql schema a gente vai importar já já
aí abre chama esse cara com objeto aí para o primeiro esquema você vai chamar
query e vai dizer new graphql object novo objeto GraphQL vai passar um objeto
e esse objeto aqui vai ter o name que é o nome vamos chamar de root query type que
vai ser a raiz a primeira né vamos falar fields essa fields vamos botar companhia
aí Comparei a companhia vamos falar tipo vamos começar bem simples tipo string
graphql string só para o nome da companhia que quando você dá o resolve resolve a gente
vai falar das coisas já já para aí resolve vai retornar o nome da companhia
exemplo tá vamos salvar esse cara ver se dá problema ou não a gente tem que
pegar esses caras vamos importar lá em cima requerir requerir vamos lá falar conste
abre as chaves para poder dar um destrutoramento vamos primeiro GraphQL
schema GraphQL object e o GraphQL string tá
e igual require GraphQL tá bom pega esses caras lá requerir do GraphQL
salvar vamos ver no que dá no servidor
então vamos ver aqui você vai lá no navegador lembra que servidor está rodando no porta
3 mil e o GraphQL no barra GraphQL vai lá no navegador abre nova tela aí localhost
3 mil barra GraphQL opa esqueci do que que ela
que aconteceu tem que matar o servidor rodar novamente opa é não se esqueça de matar o
servidor rodar novamente quando você mudar o código então tem o problema que GraphQL
construct ou o que aconteceu ver aqui GraphQL object ah desculpa vamos ver aqui
que eu fiz
e
e
dippedkk tm
em לא
väl
...is not a constructor...
Vamos lá olhar na...
...documentação do GraphQL.
Se você esquecer...
...com uma referência vai lá no GraphQL, NPM.
Olha aqui na documentação...
Ah, esqueci...
...de dizer object type, desculpa.
Tá dizendo aqui na documentação, já dá pra ver.
Eu esqueci do type.
Então vamos lá...
...de volta lá pra editor de texto,
tem que dizer object type.
Ah, tá, não esqueci do type aqui.
Vamos lá...
Quando salvo, tem que matar o servidor e rodar novamente.
Então...
...para você não ter que fazer isso,
é instalar o NodeMod.
Então vamos lá fazer isso.
Dá NPM install,
traço, traço, save dev,
para salvar só com dependência de desenvolvimento.
O NodeMod.
NodeMod vai reiniciar o servidor toda vez que você mudar o código.
Aí instala esse cara aqui.
Vai no...
...seu editor de texto.
Pronto, instalou.
Vai lá no package.json, confirma que está o NodeMod na dependência.
Aí adiciona o script aqui.
Adiciona o start.
E fala NodeMod.
É, nem pensei ser start,
para ser start, dev, alguma coisa assim.
Run dev, vamos falar dev.
Quer desenvolvimento.
O start seria mesmo o para Node index, né?
Start seria Node index.js.
O dev vai ser NodeMod index.js.
Vai desenvolver.
Não se esqueça.
Então temos dois novos comandos.
Primeiro é NPM start e o NPM run dev.
Você pode dizer NPM start,
que é um caso especial.
Ele vai dar o Node index.js, rodar o servidor.
Ou pode dizer NPM run dev.
Tem que falar run, porque o caso especial só é para start e para test.
Entrando no run dev, vai rodar o NodeMod, que está rodando aqui.
Se você fazer a mudança, olha aqui.
No arquivo do seu esquema, por exemplo,
eu vou mudar aqui para...
fiz um erro aqui.
Salvar.
Note que já reinicia.
Salvar novamente.
Está rodando de novo.
Então esse é o NodeMod.
Então com isso, a gente volta aqui no navegador.
Fechar essa tela.
De volta.
N.C.S. GraphQ.
Aí, parece o GraphQ.
GraphQ, sei lá.
Como é que eles se chamam?
Como é que vocês se chamam em português?
GraphQL.
Está certo?
Então a gente vai fazer as queries aqui.
Então vamos rodar primeiro a query.
Vamos falar aí.
Vamos falar aí a companhia.
Vê no que dá.
Tá?
Então a gente só fala companhia.
Eu quero a companhia. Me dá a companhia.
Ele já fala data sempre, com o objeto, companhia, que tem o nome da companhia.
Então vamos dar uma olhada nesse negócio.
Tá?
Vamos dar uma olhada aqui.
Já, já na próxima aula, certo?
Até mais.


000f-05 Fazendo a Root Query e Abrindo o GraphiQL (Primeiros Passos no GraphQL)

Sobre o Ponto de Partida (Root Query) do GraphQL (Aula Tutorial)

# Resumo do Transcript

## Introdução
- Discussão sobre a root query no GraphQL, que é a primeira query a ser definida no esquema.

## Root Query
- A root query é fundamental para realizar a busca de dados no GraphQL.
- Ao fazer uma query, o GraphQL utiliza as "fields" (campos) do esquema.
- No exemplo, há um campo chamado "companhia".

## Estrutura de Dados
- A "companhia" é do tipo string, e o resolve define como obter esse dado.
- O resolve pode retornar um valor direto (ex: "apple") ou uma promessa, especialmente quando se trabalha com operações assíncronas, como chamadas a um banco de dados via ORM.

## Esquema GraphQL
- Para começar, deve-se criar um esquema GraphQL, definindo um objeto query.
- Exemplo de criação:
  ```javascript
  const RootQuery = new GraphQLObjectType({
    name: 'RootQueryType',
    fields: {
      companhia: { type: GraphQLString, resolve: () => 'apple' }
    }
  });
  ```

## Template para Criação de Novos Campos
- É possível adicionar outros campos ao esquema, como "companhias" ou "produtos".
- Importância de definir o tipo e o resolve para cada campo criado.

## Conclusão
- A próxima aula abordará a criação do tipo para "companhia".

Estamos de volta, vamos entender o que aconteceu?
Então, nós fizemos a root query, que é a query-rais, que vai ser a primeira para definir
aqui no esquema, que é quando você vai lá para o GraphQL e vai bater a primeira aqui,
quando você faz a sua query, não é o que ele só disse, abrir as chaves, companhia.
Por isso, ele vem aqui no root query, olha aqui, aí ele pega e acha companhia, porque
está dentro das fields, você pode ter várias fields, nesse caso, tem um que é companhia.
Então, companhia de tipo, o quê? Essa estrutura aqui de dados, é um propriedade tipo string.
Resolve a função que você vai usar para dizer o GraphQL como obter esse dado aqui,
esse dado aqui. Como é que você obter e acompanhar? Você está dizendo é só retornar
a string apple. Então, resolve, você pode retornar um valor que ele vai ser resolvido
e vai aparecer dentro do objeto companhia lá, da propriedade, né?
Então, o resolve pode ser também a promessa, você pode retornar a promessa, por exemplo,
você faz o pd, você usa o ORM para poder obter dados do banco de dados,
esse operação é acícrona, então, você recebe uma promessa e você retorna a promessa
aqui e o GraphQL vai pegar aquele valor e vai retornar para você.
Está bom? Note que o valor retornar aqui tem que ser, está igual ao tipo aqui, né?
GraphQL string, retornando a string. Então, essa root query que você tem que ter para poder
onde tudo começa, né? Então, você faz o seguinte, você faz primeiro um esquema de GraphQL,
GraphQL schema, não se esqueça de falar para o Chave New, faça um objeto, aí você chama query,
está query, aí você fala, você cria um novo objeto, GraphQL, object type, tipo objeto,
e aí você diz o nome dessa cara, vai ser root query, está porque é a raiz, né?
ROOT, aí diz as propriedades, os campos, nesse caso só tem companhia, aí você pode adicionar mais,
pode adicionar companhias, entendeu? Pode adicionar, sei lá, como é, produtos e assim por diante,
qualquer coisa aqui, está? Então, vamos começar simples assim, companhia, aí cada,
esse cara, você tem que ter o tipo, tipo é GraphQL string, aí tem que dizer o resolve,
dizer como é que acha esse dado, propriedade aqui, está? Sempre assim, então com isso,
vamos fazer aqui um tipo para companhia, está bom? Vamos fazer isso lá na próxima aula,
é?


000f-06 Sobre o Ponto de Partida (Root Query) do GraphQL (Aula Tutorial)

Esquema de GraphQL para Companhia (Aula de API JSON com Express)

# Resumo da Aula sobre GraphQL

Nesta aula, o instrutor apresentou como criar um tipo de objeto em GraphQL chamado "companhia". A seguir, um resumo das etapas e conceitos abordados:

1. **Definição do Tipo Compania**:
   - O tipo de objeto é criado através de `GraphQLObjectType`.
   - Estrutura do tipo inclui:
     - `id` (tipo: `GraphQLInt`)
     - `nome` (tipo: `GraphQLString`)

2. **Implementação**:
   - O tipo é nomeado como "companhia" e os campos são definidos como `fields`.
   - O código básico para definição é:
     ```javascript
     const companhiaType = new GraphQLObjectType({
       name: 'Companhia',
       fields: {
         id: { type: GraphQLInt },
         nome: { type: GraphQLString }
       }
     });
     ```

3. **Consulta e Resolução**:
   - O instrutor simula uma consulta no GraphQL para verificar quais dados podem ser retornados.
   - A consulta pode ser ajustada para retornar apenas o `id`, o `nome` ou ambos, dependendo da solicitação do cliente.
   - O servidor filtra e responde apenas com os dados solicitados, utilizando o resolver.

4. **Demonstração**:
   - Mostra como, ao enviar uma query para o servidor, somente os campos solicitados são retornados:
     - Exemplo de query para obter apenas o `id`:
       ```graphql
       {
         companhia {
           id
         }
       }
       ```
     - Resposta: Apenas o ID é retornado.

5. **Conceitos Chave**:
   - GraphQL permite que o cliente especifique exatamente quais dados precisa, evitando o envio de dados desnecessários.
   - A comunicação entre o cliente e o servidor é gerenciada pelo middleware `express-graphql`.

### Conclusão
A aula finaliza com a reafirmação de que a construção de tipos em GraphQL é feita através da definição de campos e tipos, permitindo um controle preciso sobre a manipulação de dados. O instrutor encoraja a prática e a exploração do GraphQL em projetos futuros.

Então, vamos de volta, vamos fazer um tipo, um esquema para companhia.
Vamos lá aqui, no arquivo esquema, pronto, já está.
Vamos fazer o variable chamada companhia type.
Esse variável vai ser um novo new, graphKL object type.
Seu tipo objeto.
Vamos definir, descrever a estrutura, como é que é esse objeto para a companhia.
A gente já viu antes, e vai ser assim, ó.
Tá?
Dessa maneira, um id e um nome.
Então, vamos lá.
Você faz isso aí, sempre tem os mesmos campos.
A mesma propriedade de objeto. Primeiro nome desse cara.
Nem vai ser o quê?
Companhia.
Aí depois, diz os campos, fields.
Esse campo é id e nome.
Então, vamos dizer id.
Então, id tem tipo o quê?
Type.
GraphKL.
Opa, mais, qual o número?
Como é que faz o número?
Então, vamos lá na referência.
Vai aqui no Firefox.
Lá naquele mesmo.
GraphKL, no NPM.
Vamos ver como é que vai lá.
Você procura.
Number.
Vê se tem, não tem.
Integer, não tem.
Então, vamos ver aqui.
Referência.
Desse tem aqui embaixo.
Eu quero olhar na referência deles.
Os tipos, né?
Lá no GitHub.
Tá aqui. Vai para essa página.
GraphKL.org.
GraphKL.js
Escrevendo código.
Você o quê? Ah, tem aqui os tipos.
Olha aqui.
Do lado direito.
A gente já sabe GraphKL string.
A gente já sabe GraphKL object type.
Acho que a deu o número.
Será que tem int?
Ah, tá aqui. Olha aqui o int.
GraphKLskill representa o inteiro.
A gente pode usar esse cara.
GraphKL int.
Tá? Vamos tentar usar.
Vamos colocar GraphKL int para o id.
Vamos requerir lá acima.
GraphKL int.
Aí, vamos ver aqui.
Depois do id tem o quê? O nome.
A companhia.
É o tipo que é type.
GraphKL string.
Já viu. Já aprendeu esse cara.
Então, a companhia tem...
A gente está descrevendo o tipo, companhia,
o nome do tipo, as campos, fields, id,
nome. O id é tipo GraphKL int.
Nome, tipo GraphKL string.
Então, tá legal isso.
Aí, você volta aqui,
em vez de falar type string,
você fala companhia type.
Referência àquela variável que a gente definiu aqui em cima.
Agora, para o resolve,
é que o negócio...
A gente não tem banco de dados, né?
Para testar isso.
Então, se tivesse banco de dados,
vamos supor que esse cara iria retornar o objeto.
Dessa maneira aqui, vamos fazer uma companhia
com um file, um id, sei lá, um, dois, três.
E, nome, ah, pô.
Retornar esse objeto.
GraphKL vai saber que é um tipo, companhia,
que vai ter o id, o nome, tá?
Aí, vamos salvar.
Olha o que acontece aqui.
Vamos lá, de volta para o navegador,
para o GraphKL localhost,
barra GraphKL, assim, note que a query aparece aqui, ó.
Se você quiser digitar aqui também.
Ah, vou dar de novo.
Deu erro porque a gente tem que escolher,
especificar, a gente tem que dizer o que a gente quer da companhia, tá?
A companhia, eu quero o id, só o id.
Você note o que aconteceu.
O GraphKL te deu exatamente aquilo que você pediu.
Eu quero que você me dê o id da companhia.
E ele te deu só o id.
Norte que lá no código, eu retornei o id e o nome,
como se fosse retornando do banco de dados.
Mas o GraphKL é responsável por ver esse negócio.
Ah, o cliente só pediu id, então só vão mandar o id.
Então ele corta o nome da cara, tá?
Se você quiser só o nome, é só dizer nome aqui, ó.
A gente companhia nome, só o nome apareceu.
Se quiser a dois, ambos, só dizer id e o nome, tá?
Olha aí.
Tá certo? Então esse é o GraphKL.
Você pede exatamente os dados que você precisa.
Nada mais, nada menos.
Exatamente o que você precisa.
E tá aí.
Então na sala a gente aprendeu, na sala,
a fazer nosso próprio tipo, companhia, type.
Sempre assim você faz GraphKL Object Type, New, Name and Fields.
Name é o nome do recurso, Fields é os campos.
Tem id, tem nome.
Aí você define o tipo de cada campo com type,
GraphKL int, GraphKL string.
Aí aqui no query, você adiciona query,
nesse caso só companhia,
quando você bater lá e perguntar, me dá um companhia aí.
E eu preciso do id e do nome.
O GraphKL vai aqui, ele pega o valor retornado, resolve,
e filtra as propriedades que você não quiser
e manda de volta pro cliente.
Então é tudo feito do servidor,
pelo middleware, express GraphKL.
Tá bom?
Por essa aula é só ir até a próxima.


000f-07 Esquema de GraphQL para Companhia (Aula de API JSON com Express)

Verificando o Pedido do GraphiQL ao Servidor (POST /graphql)

# Resumo da Aula sobre GraphQL

Nesta aula, o instrutor aborda o funcionamento de requisições GraphQL ao servidor, usando o Chrome DevTools para demonstrar o processo.

## Principais Pontos:

- **Análise de Requisição**: O instrutor analisa a aba de "Network" no DevTools para visualizar a requisição feita ao clicar no botão de Play, que envolve uma query para uma companhia.
  
- **Estrutura da Query**: O GraphQL retorna uma boa estrutura de dados, incluindo ID e nome da companhia. O pedido é feito via método POST para o endpoint `/graphql`.

- **Endpoint Único**: É enfatizado que no GraphQL todas as operações acontecem através de um único endpoint. Neste exemplo, o Express GraphQL é utilizado como middleware.

- **Formato do Pedido**: O pedido contém um objeto JSON com as propriedades `query` e `variables`. Embora as variáveis ainda não sejam usadas, a propriedade `query` é, de fato, uma string que define a consulta.

- **Estrutura da Query**: A estrutura da query é explicada, com referências a chaves e que a palavra-chave implícita "query" deve ser considerada para definir consultas no esquema.

- **Mutations**: O instrutor menciona que futuramente haverá uma diferença entre queries e mutations, que são usadas para modificar dados.

## Conclusão
A aula conclui enfatizando que o pedido GraphQL é um POST para `/graphql` e que o formato do pedido consiste em um objeto JSON com a propriedade `query`. A introdução a mutations será abordada em aulas futuras.

Vamos lá pessoal, estamos de volta.
Nesta aula vamos falar aqui, vamos ver o que está acontecendo quando o GraphQL faz um
pedido ao nosso servidor.
Vou analisar isso, estou aqui no Chrome, vou abrir a DevTools e na aba de Network, que
é rede, eu vou verificar aqui o pedido que vai ser feito quando a gente clicar no
botão de Play.
Então temos aqui uma query, query para uma companhia, ok?
Olha aqui que o GraphQL já diz, good query type, companhia, companhia, você pode até
analisar a estrutura de dados da companhia, que tem o ID, o nome e o formato, né?
Tem o int e o tipo.
Bem legal, mas vamos lá, vamos clicar Play, aí vamos ver aqui a resposta.
Olha lá aqui, a resposta é essa, que a gente tem um objeto e dentro de data tem a companhia
com o ID e nome.
Mas qual é o pedido?
Essa é a resposta, mas eu quero saber o que é que o pedido foi esse que o GraphQL
fez.
Então ele fez um post, olha o verbo aqui, para o barra GraphQL, que é o nosso endpoint.
Lembre-se de que no GraphQL tudo é feito por meio de um único endpoint.
Nesse caso aqui, usando o GraphQL Express, que é o middle-air de express, ele vai bater
lá no barra GraphQL, no nosso servidor Express, e vai rediracionar esse cara para
o middle-air, express GraphQL, que vai fazer a operação desejada.
Então ele faz um post, barra GraphQL e manda o quê?
Olha aqui embaixo.
Ele vai mandar esse pedido com o seguinte objeto, com a propriedade query e propriedade
variables, que são as variáveis.
A gente não tem variável ainda, mas só tem a query.
Então olha query on string que define a query.
Nesse caso, abre as chaves, esse set indica uma quebra de linha, companhia abre a chave,
quebra de linha ID, quebra de linha nome, quebra de linha fecha a chave, quebra de linha
fecha a chave, entendeu?
Então você note que está dentro da palavra chave, propriedade query.
A gente vai aprender depois, depois que existe outra maneira, não tem só query, tem também
chamada mutation, a mutação para poder modificar dados.
Então, nossa query.
Então na verdade, quando a gente estava digitando GraphQL, tem uma palavra chave implista aqui,
que é a query.
Então quando você faz um query, na verdade, esse aqui é um query.
Por isso que quando você vai lá definir o seu esquema na query raiz, você fala query
aqui.
Essa query significa esse cara aqui, se refere a esse cara aqui e dentro de query tem as
fields, que é os campos, que é a companhia e está aqui.
Por isso que é assim.
Vou clicar funciona, tá?
Por isso que está aqui também, olha.
Query, esse é o empurjante.
Então é só isso nessa aula, só queria que você entendesse que o pedido que o GraphQL
faz é um post para o barra GraphQL e a gente viu aqui que ele manda um objeto, formato
JSON, que é a propriedade query, com a query em uma stream e essas variables aqui que a
gente ainda não usa.
Entendemos que é implicitamente coisa que a gente fez claramente, na verdade, uma query.
Então você põe a adicionar a palavra chave para ser explícito aqui query para diferenciar
logo adiante que vai ter a chamada mutation.
Tá?
Por essa aula é só e até a próxima.


000f-08 Verificando o Pedido do GraphiQL ao Servidor (POST /graphql)

Banco de Dados Simulado para nosso GraphQL

# Resumo da Transcrição

## Introdução
O apresentador reintroduz o assunto sobre GraphQL e menciona a necessidade de simular um back-end para o aprendizado. O projeto visa explorar o relacionamento entre companhias, produtos e modelos.

## Estrutura do Projeto
- **Companhia**: Contém vários produtos.
- **Produto**: Possui vários modelos.
- Exemplo: A Apple tem produtos como o iPhone, que inclui modelos como o iPhone X.

## Simulação do Back-end
O back-end será simulado, e um banco de dados fictício será criado usando um ORM (Object-Relational Mapping).

### Funções Planejadas:
1. **Companhia**:
   - `companhia.findall`: Retorna todas as companhias.
   - `companhia.findpouid`: Retorna uma companhia específica pelo ID.

2. **Produto**:
   - Criação de uma API externa simulada para obter produtos.
   - Métodos como `findProduct` e `findProductById`.

3. **Modelo**:
   - Funções como `modelo.findAll`.

A ênfase é que no GraphQL, os dados podem ser obtidos de várias fontes, sejam elas centralizadas ou externalizadas.

## Criando a Estrutura do Projeto
1. Criar pastas para os módulos:
   - `models`: Para simular o banco de dados.
   - `API`: Para a API externa simulada.

2. **Companhia.js**:
   - Definir uma função `findAll` que retorna uma promessa com uma simulação de uma requisição HTTP.
   - Simular um tempo de espera de 0.3 segundos antes de resolver a promessa com os dados das companhias.
   - Inicializar dados fictícios como Apple, Google e Microsoft.

### Exemplo de código
```javascript
let companhias = [];
function findAll() {
    return new Promise((resolve) => {
        setTimeout(() => resolve(companhias), 300);
    });
}
module.exports = { findAll };
```

## Testes
O apresentador menciona a verificação do código através do console.log para garantir que a função está funcionando corretamente e retornando a lista de companhias.

## Conclusão
O apresentador planeja voltar na próxima aula para integrar o uso do ORM em vez de chamadas diretas no esquema de GraphQL.

--- 

**Próximo Passo**: Continuar o desenvolvimento do projeto integrando o ORM para interagir com os dados simulados.

Olá pessoal, estamos de volta.
Então antes da gente continuar a falar onde o GraphQL, a gente precisa simular um back-end
para poder fazer essas coisas.
Se você se lembra, a gente quer, nesse projeto, aprender GraphQL usando o seguinte relacionamento.
Primeiro você tem uma companhia.
A companhia tem vários produtos.
E cada produto tem vários modelos.
Por exemplo, a Apple tem vários produtos, por exemplo, o iPhone.
E o iPhone tem vários modelos, por exemplo, o iPhone X.
E assim por diante.
Então tem esse relacionamento.
Para a gente poder trabalhar com isso, vamos fazer um back-end simulado.
Então vai ser assim, olha.
Então para a companhia, a gente vai fazer como se fosse um banco de dados simulado.
Simulado com o ORM.
A gente vai poder fazer assim o seguinte.
A gente quer fazer uma função, um módulo que você pode fazer assim.
A gente vai fazer companhia.findall, quando você chama esse cara retorna a promessa,
que vai te dar todas as companhias que a gente vai fazer, simular.
E você pode também fazer companhia.findpouid, tá?
O id da companhia.
Agora para o produto, eu quero...
A gente poderia fazer a mesma coisa, mas para ilustrar que o GraphQL,
você pode pegar os dados não só de um lugar central, mas de qualquer outro local.
Pode ser até de um API externo.
Eu vou fazer uma API externo simulada, tá?
Então a gente vai fazer API externo simulada.
E vamos fazer o seguinte, API, ponto.
Vamos falar findProduct.
Tá?
Productus.
Tem que ver o negócio aqui, o relacionamento.
Se eu falar findProduct, vai ser todo.
Se eu falar findProduct, puid, vai ser um produto específico.
Pode ser que haja outros, por exemplo, findProducts pela companhia, alguma coisa assim.
Então a gente vai ver depois.
Eu gostaria também de fazer para o modelo, vou fazer o banco de dados simulado via ORM.
Vamos fazer outro módulo.
Modelo.findAll.
E assim por diante.
Alguma coisa assim, tá?
A gente vai ver lá na frente.
Então isso é para ilustrar que no GraphQL, não importa se os seus recursos estão centralizados num só local
ou se estão descentralizados em vários outros locais diferentes.
Pode ser que sua companhia esteja localizada no banco de dados local.
Pode ser que o produto seja obtido via um API de outros serviços.
Pode ser que o modelo tenha no banco de dados que não está local, mas está em outro local.
Lugato, tá?
Então vamos fazer esse cara aqui.
Então vamos começar aqui dentro do nosso projeto.
Vou criar uma pasta.
Vamos chamar, sei lá, recursos.
Não sei, API, recurso, qualquer coisa.
Vamos chamar o R&M aqui.
Modelos, que tal.
Vou chamar models.
E vou...
Criar outra pasta para API.
Vou chamar o R&M mesmo, desculpa.
Vou chamar um pasta de API e outro de R&M.
Vamos começar a companhia aqui.
Primeiro de tudo, a gente quer pegar um listro de todos os companheiros.
Então vamos aqui na pasta R&M, vou criar companhia.js.
Esse modo.
Então nesse modo vamos falar de um modo export.
Vou passar um objeto aqui.
Vou definir uma função chamada findAll.
Aqui não me leva nenhum argumento.
E nessa função, vamos fazer o seguinte.
Vamos definir aqui fora, simular um banco de dados.
Eu vou dizer let, companhias.
E vou botar uma lista vazia, por enquanto.
Aí quando você define, ele vai retornar a nova promessa, está certo?
New promise.
Para simular um pedido real de HTTP.
Model setTimeout.
Para simular aquela espera.
Vamos dar uns 3 milissegundos, que é 300.
Desculpa, 0.3 segundos, 0,3 segundos, que é 300 milissegundos.
E vamos dar um resolve aqui com as companhias.
Tá bom?
Então, a gente dá o Model Exports aqui para disponibilizar o findAll, que retorna a promessa.
E depois de 0,3 segundos, ele dá o resolve com a lista de companhias desse banco de dados falsos.
Banco de dados simulado.
Agora não tem nada, então seria legal se a gente tivesse já dados inicialmente.
Se eu adicionar um aqui.
Adicionar Apple, e nome, opa, o ID errado.
O ID era int, não era?
Deixa eu ver aqui, esquema era int.
Então, o ID, o nome.
Vamos botar outra, sei lá, qualquer companhia que você...
Sei lá, Americanas.
E...
Uma outra companhia, sei lá, Microsoft.
Vamos deixar três recordes aqui no nosso Banco de Dados Simulado para a companhia.
Eu não sei o que a produto Americanas tem, na verdade, então vamos mudar.
Vamos mudar isso para, sei lá, para a Google.
Apple, Google Microsoft, deixe aí.
Então, vai resolver essa lista quando você chamar.
Esse cara está simulando como se fosse um OIM.
Para testar isso, deixe eu só ir no index.
E qualquer canto aqui, eu só chamar.
Vou dar o require.barrorm.companhia.findall e dar o console log.
Dá para testar aqui.
Só vai ver o terminal aqui.
Então, a promessa que está pene, a gente tem que lidar com essa promessa usando o ponto den.
Ponto den e dar o console log dentro do ponto den.
Den, resposta.
Console log resposta.
Salvar. Está aí, certo? Então deu certo.
E tornou a lista.
Então, está funcionando.
Vou remover isso.
Salvar.
E agora, em vez de a gente pegar a companhia aqui no nosso esquema,
vamos lá voltar para o esquema.
Em vez de a gente pegar a companhia aqui,
só de um objeto aqui, a gente vai chamar o R&M para pegar do banco de dados simulado.
Então, vamos fazer isso na próxima aula.
Até lá.


000f-09 Banco de Dados Simulado para nosso GraphQL

GraphQLList e resolve no GraphQL (Lista de Companhias)

```markdown
# Resumo da Transcrição

O autor demonstra a implementação de um ORM simulado para acessar um banco de dados com uma lista de companhias. Ele aborda o processo de criação de uma query para recuperar todas as companhias usando GraphQL.

## Passos Principais:

1. **Modificação da Query**:
   - O autor altera a query `companhia.findAll` para `companhias`, permitindo a recuperação de todas as companhias.

2. **Atualização do Tipo de Retorno**:
   - O tipo de retorno é definido como uma lista de companhias usando `new GraphQL.List(companhiaType)`.

3. **Importação Necessária**:
   - O `GraphQL.List` é importado no início do arquivo.

4. **Função Resolve**:
   - A função `resolve` é configurada para usar `companhia.findAll`, que retorna uma promessa com a lista de companhias.

5. **Importação de Companhia**:
   - O autor mencionou a necessidade de importar a definição de `companhia` com `const companhia = require('bar/orm/companhia')`.

6. **Execução da Query**:
   - Após salvar as alterações e reiniciar, o usuário pode executar a query para obter a lista de companhias, retornando o `id` e o `nome`. O usuário pode personalizar a resposta removendo campos indesejados.

7. **Próximos Passos**:
   - Na próxima aula, será abordada a implementação de uma query para recuperar uma única companhia utilizando seu `id`.

## Conclusão
O autor finaliza a aula enfatizando que o GraphQL agora sabe como encontrar a lista de companhias através do configure `resolve`.
```


Fala pessoal, acabamos de fazer aqui esse ORM simulado para poder acessar esse banco
de dados simulado com a lista de companhias, sem três.
Então vamos a esse find all, companhia ponto find all, aqui para poder fazer uma query
para pegar todas as companhias.
Então aquela companhia aqui query que você já tem, vamos mudar esse cara aqui e depois
a gente faz só um só companhia.
Então vamos mudar esse cara para companhias, eu estou no arquivo schema.js na query-raiz,
tem o campo companhias que a gente vai fazer para poder pegar a lista de todas as companhias.
Agora o tipo desse cara vai ser o quê?
Não é mais só um objeto, né?
Companha type.
É vários.
Então para poder fazer esse negócio você tem que fazer, definir esse cara não como
um só companhia type, mas com uma lista de GraphQL.
Então você vai fazer o seguinte, vai dizer new GraphQL list, tá?
Aí você passa o companhia type para ele.
Aí eu digitei dois queis.
Vamos lá em cima importar o GraphQL list.
GraphQL list lista, tá?
Do GraphQL, dá o require lá em cima e aqui faz new GraphQL list com companhia type.
Agora o resolve vai mudar, que resolve aquela função que é usada para poder dizer ao GraphQL
como encontrar esse recurso.
Então agora mudou.
Para encontrar o recurso a gente tem que falar o quê?
Companhia, find all, esse cara retorna a promessa, depois é resolvida com a lista de companhias.
Agora você pode retornar isso do resolve, que o resolve já sabe, ah, você retornou
a promessa, tá bom, vou esperar e vou retornar o valor resolvido pela promessa.
Quando for fazer a resposta para o cliente, tá?
Agora a companhia a gente tem que importar esse cara aqui.
Então vamos lá em cima requerir com a companhia, é igual require.bar orrm.companhia, tá?
Depois disso é só salvar.
Vamos ver agora no que dá quando a gente fazer query para todas as companhias, olha aqui.
Eu vou botar aqui no GraphQL companhias no plural, deixa eu reiniciar, tá?
Então olhando o que dá, já abriu aqui e executou a query,
está te dando a lista de companhias com o id e nome, se eu quiser só o id é só remover o nome.
E se eu quiser só o nome é só remover o id, tá?
Aí, então o GraphQL sabe, a gente disse o GraphQL como encontrar a lista de companhias,
é só no resolve aqui.
Tá legal? Agora, vamos ver aqui.
Na próxima aula a gente vai ver como fazer uma query para uma só companhia usando o id daquela companhia
para poder encontrá-la. Então até lá.


000f-10 GraphQLList e resolve no GraphQL (Lista de Companhias)

Query de GraphQL com Argumentos! (Args e GraphQLNonNull)

# Resumo da Aula sobre Query para Encontrar Companhia por ID

Nesta aula, o objetivo foi aprender a criar uma query em GraphQL para buscar uma companhia específica pelo seu ID. 

## Passos Abordados:

1. **Configuração da Query**:
   - Retornamos à query raiz e adicionamos a `companhia` nos `fields`.
   - Definimos o tipo como `companhia type`, pois a busca será para um único item, não uma lista.

2. **Definição de Argumentos**:
   - Adicionamos uma propriedade chamada `args`, onde definimos o argumento `id`, do tipo `GraphQL int`, que não pode ser nulo.

3. **Uso do Resolve**:
   - Implementamos a função `resolve` que utiliza `args` para encontrar a companhia pelo `id`.
   - O `parent value` é mencionado, mas não utilizado neste momento; o foco foi nos argumentos.

4. **Captura de Dados**:
   - Ao testar no terminal, o `args` mostrou o ID fornecido, enquanto `parent value` estava indefinido.

5. **Implementação do Método Find**:
   - No arquivo `companhia.js`, foi adicionada uma nova propriedade `find` que retorna uma promessa.
   - Simulamos um atraso utilizando `setTimeout` e utilizamos `find` para localizar a companhia cujo ID corresponde ao fornecido.

6. **Tratamento de Resultados**:
   - Se a companhia for encontrada, retornamos o resultado, caso contrário, podemos decidir entre retornar `null` ou rejeitar a promessa com um erro.

7. **Teste da Query**:
   - A query foi testada no GraphQL, onde diferentes IDs foram utilizados para buscar companhias (Google, Microsoft, Apple).
   - Observou-se que o uso de aliases era necessário ao fazer múltiplas consultas para o mesmo campo.

## Conclusão:
Na aula, aprendemos a criar uma query para retornar uma única companhia com base no ID, definindo argumentos que não podem ser nulos e implementando a lógica de busca através de funções JavaScript. As consultas foram testadas e funcionaram conforme esperado. 

Até a próxima aula!

Fala pessoal, vamos continuar a fazer um tipo de query para poder encontrar uma companhia
por id.
Então a gente gostaria de voltar para aquele companhia no singular e gostaria de procurar
a companhia pelo id.
Para poder fazer isso, vamos fazer o seguinte, voltando ao editor de texto, aqui na nossa
query raiz, em fields, você vai adicionar companhia e vai ser a query para companhia
individual.
O tipo vai ser o seguinte, companhia type, porque é só um, não precisa de lista.
Agora vamos ter o seguinte propriedade chamada args, argumentos.
Para argumentos vamos ter o seguinte, vamos ter o id.
Esse id vai ser tipo o quê?
Tipo vamos usar a GraphQL int, tá?
Mas esse id não pode ser no.
Então a gente tem que usar o seguinte, vamos usar essa, a gente vai dizer new GraphQL,
no no e passo GraphQL int como um argumento para esse cara.
Para dizer que você não quer deixar esse cara ser no.
Então você sempre tem que dizer um id não pode ser no, tá?
Tem que dar o id.
Então a gente tem a propriedade args, que vai ser usada para poder receber o id como
argumento lá da nossa query.
E esse id é tipo int, GraphQL int, mas não pode ser no.
Então a gente fala new GraphQL, no no e passa esse cara como argumento, tá certo?
Aí depois do args vamos falar o resolve, que a gente tem que dizer o GraphQL como é
que vai achar a companhia.
Mas para resolve você tem que pegar o id da companhia.
Você vai chamar o quê?
Companhia.find que a gente vai defender já já e passa o id, mas cadê o id?
Como é que você acha id?
Então vai vir do resolve.
Resolve tem argumentos aqui, parâmetros, o primeiro vamos chamar de parent value, o
segundo vamos chamar de args.
Então os argumentos que vai vir da query vão estar dentro do objeto args.
Então você vê isso, vou dar o console log aqui, parent value e de args.
Tá?
Quando a gente dessa query, salvar, vou aqui atualizar, deu problema que eu esqueci de
importar o requerer.
Aí eu GraphQL no no, vou no mais cima, GraphQL no no, salvar.
Volto lá para o navegador, olha só o que acontece.
Field, companhia, argumento id, de tipo int é requerido, é obrigatório, mas não
foi fornecido.
Então o que a gente vai fazer aqui na companhia, olha só, para poder você passar argumentos,
você abre os parâmetros e diz o nome do argumento, nesse caso id, a id 2 pontos, o id, vamos
tentar id 2 que vai ser Google, não tem nada ainda porque a gente não fez o resolve.
Mas vamos olhar o terminal.
No terminal você vê o parent value está undefined, a gente não precisa preocupar com isso agora,
mas o args aparece o id 2 aqui que veio lá desse cara aqui.
Tá certo?
Então vamos continuar nosso resolve aqui, vou deixar o console log para você ver, a
gente tem que retornar companhia.find com o args.id que é o id, companhia a gente para
procurar, mas agora a gente tem que definir o find, vamos lá no nosso arquivo companhia.js,
adiciona nova propriedade desse objeto chamada find e põe o id, um argumento, aí vamos
retornar nova promessa, aquela mesma coisa resolve, reject, criando essa nova promessa,
então set time out para simular uma espera, trazentos, aí vamos dar o resolve com o que?
A gente tem que encontrar primeiro, companhias aqui é um list para poder encontrar aquele
objeto cujo id é aquele fornecido, você vai usar a função find, então a gente pode
usar o find, companhias.find, companhia, o companhia id é igual ao id fornecido,
deixa eu extrai esse cara para fora, então para fora desse cara vou falar consta, a
companhia, então eu usei o find para poder encontrar companhia, então se a companhia
não forneu, você vai dar o resolve com a companhia, mas se forneu, dá o resolve, na verdade
poderia resolver, retornar no ou retornar um, rejeitar com um erro, depende de você, eu
vou deixar assim mesmo, vou resolver sem, nada, vou resolver, mesmo que esteja no, vai
resolver no, então você encontra a companhia e resolve que salvar, volta para o esquema,
está definido agora, vamos salvar o esquema, vai no graph view, executamos a query e funcionou,
vamos mudar o id, 3, microsoft, vamos mudar para um, apple, eu quero só o nome da companhia,
vou colocar o id aqui, está certo, então você pode fazer várias queries aqui, companhia
id 3, o id e nome, e o nome, nesse caso dessa maneira não dá, tem que usar alias,
ele é só diferentes, então não dá, então é isso, na sala a gente aprendeu a fazer a query
para que um só companhia, temos um args, definimos argumentos que levam aqui no parênteses,
definimos id para ser não null
e definimos o resolve, fizemos o companhia.find para encontrar a companhia por id
tá certo? então por essa aula é só e até a próxima


000f-11 Query de GraphQL com Argumentos! (Args e GraphQLNonNull)

Criando um Schema de GraphQL para o Produto

# Resumo do Transcript

No vídeo, o apresentador discute a criação de um sistema para gerenciar produtos e companhias usando GraphQL. Aqui estão os principais pontos abordados:

## Introdução
- O apresentador retorna ao projeto e remove um console.
- Ele revisita as queries já feitas para buscar companhias por ID.

## Criação de Produtos
- O foco agora é agregar a funcionalidade para os produtos.
- É mencionado que as companhias têm múltiplos produtos.
  
## Implementação
- O apresentador inicia uma nova query para obter produtos.
- Criação de um novo tipo de GraphQL chamado `Produto`, que inclui campos como ID, nome do produto e ID da companhia.
- A função `API.findProducts` é utilizada para simular uma API externa e retornar os produtos.
  
## Definições
- Utiliza `GraphQL object type` para definir o tipo `Produto` com campos: `id`, `nome`, e `companhia ID`.
- Exemplos de produtos são definidos (iPhone e iPad) e associados a uma companhia ID específica.
  
## Simulação de Resposta
- Uma promessa é utilizada para simular o retorno dos produtos após um tempo de espera.

## Problemas e Soluções
- Apresentador encontra um erro relacionado a definições de tipo e corrige, garantindo que os produtos sejam tratados como uma lista.

## Próximos Passos
- Aborda a necessidade de relacionar produtos com suas companhias na próxima aula, permitindo buscar produtos específicos de uma companhia.

A sessão termina com a promessa de que a próxima parte abordará a implementação de relacionamentos entre produtos e companhias.

Malu, pessoal, estamos de volta.
Deixa eu remover esse console logo daqui, do companhia tá.
Então, a gente fez a query pra pegar todas as companhias e pra pegar uma companhia por ID.
Legal.
Então, vamos continuar nosso relacionamento.
A gente já aprendeu que a companhia tem vários produtos.
Então, vamos fazer os produtos.
Então, vamos lá.
Eu vou aqui.
A gente vai fazer uma nova...
novo tipo de query
pra pegar os produtos.
Tá?
Aí, depois, a gente vai conectar com a companhia.
Então, deixa eu adicionar produtos aqui.
Então, essa query, vamos fazer juntos.
Produtos tipo é o quê?
A gente não tem produto type ainda, mas a gente vai fazer já já.
Produto type.
Args.
Não tem Args.
Então, vou tirar.
Resolve.
Resolve.
Tem que pegar API, se lembra?
Então, a gente vai usar API.findProducts
pra simular outro API externo.
Vamos dizer API.findProducts, que vai retornar o promesso
e retorna o resolve.
Tá?
Então, vamos definir o produto type aqui em cima.
Antes do companhia type, com os produtos type.
New GraphQL object type.
Passa um objeto.
Qual o nome? Name?
Produto.
Qual as fields? Camps?
Primeiro ID.
Vai ser type GraphQL int, mesma coisa.
Vamos também passar o nome do produto.
Vamos usar a mesma coisa, basicamente.
GraphQL string.
Tá?
E vão também adicionar a relacionamento.
O ID.
Começa só pro companhia ID.
Type.
GraphQL int.
Só pra ter aqui, mas depois a gente vai definir
relacionamento.
Então, esse produto pertence à companhia com o ID aqui.
Então, vamos salvar.
E vai ir lá pra API, fazer um arquivo.
Vai lá index.js.
Módulo.exports.
Fazer aquela mesma coisa.
FindProducts.
Vamos retornar a nova promessa.
Resolve.reject.
Então, vamos fazer o banco de dados só aqui.
Let.
Product.b.
Vamos usar a lista.
Aí, vamos fazer um produto.
Pra API vai ser...
Vamos usar outro ID aqui, sei lá.
Aqui a gente tem...
Parece que aí deu o mesmo.
Então...
O nome vai ser iPhone.
Companhia ID.
Se você olhar na banco de dados fácil vai ter ID 1.
Aí faz mais.
Zé.
Sei lá, iPad.
Companhia ID 1.
Deixa o só assim mesmo, depois a gente faz mais para as outras companhias.
Então, iPad ou iPhone.
Aí retorna aqui do new promise.
Você vai dar o set time out para simular uma espera.
300.
E vamos retornar...
Não retornar, mas resolver com produtos.
Simular como se fosse uma API externa, tá?
Em outro lugar.
Com isso, a gente vai aqui de volta ao esquema.
Vamos requerer lá em cima.
É, produto require.bpibarra...
Pode pôr o index, mas se for o nome especificamente index não precisa dizer.
Ah?
Legal, vamos ver se funciona essa query.
Está aqui, retorna, findProduce.
Deixa eu dizer outra aqui.
Produtos...
Ah...
ID, nome.
Opanhia ID.
API não está definida.
Ah, desculpa.
RAPI, não produto.
Aqui em cima.
Você dá o require API, não produto.
Alvar, de novo.
Legal.
Legal.
Deu problema porque a gente esqueceu de fazer lista.
Pro...
Produtos é plural, não é segundo lá, então esse tem que ser o quê?
Esse tipo.
New.
RAPQL.
List.
Tá?
Salva.
Tá?
Salva.
Tá aí.
Então, eu espero pegar todos os produtos.
iPhone, iPad, companhia ID.1, mas não tem relacionamento com companhia agora.
A gente só sabe o ID.
Então a gente tem que arreglar o maneiro de fazer o seguinte.
Você está aqui em cima na companhia, ó.
Você pode dizer, eu quero os produtos.
E para cada produto, me dê o nome do produto.
Ou qualquer coisa mais.
Então a gente tem que fazer relacionamento na próxima aula.
Até lá.


000f-12 Criando um Schema de GraphQL para o Produto

Relacionando Companhia com Produto (1 para N / Um para Muitos no GraphQL)

```markdown
# Resumo da Aula: Relacionamento entre Companhia e Produtos

## Introdução
Na aula, discutimos como estabelecer um relacionamento entre companhias e produtos. O objetivo é que uma companhia possa ter vários produtos associados.

## Query para Obter Produtos de uma Companhia Específica
- Queremos uma query que retorne todos os produtos de uma companhia específica (por exemplo, a companhia com id 1).
- A estrutura da query raiz foi definida, e foi adicionado um campo chamado `produtos` ao tipo `companhia`, que representa uma lista de produtos.

## Definindo o Campo `produtos`
- O campo `produtos` é um tipo de lista de `produto type`.
- Precisamos usar a função `resolve` para especificar como encontrar os produtos associados a uma companhia. A função `resolve` utiliza `parentValue` e `args` como parâmetros.

## Implementação do Método de Busca
- Dentro da implementação, usamos a função `find_produtos` para filtrar os produtos com base no `companhia_id` fornecido.
- Adicionamos novos registros no banco de dados simulado para os produtos da Microsoft e Google.

## Código do Método `find_produtos`
- Define um método que simula uma espera (300 milissegundos) e filtra os produtos onde `produto.companhia_id` corresponde ao `companhia_id` fornecido.

## Chamando a API
- Utilizamos a função `find_produtos` na classe `companhia`, passando `parentValue.id` como o id da companhia.
- O resultado é uma nova promessa que, ao ser resolvida, retorna a lista filtrada de produtos.

## Exibição dos Resultados
- Após atualizar o navegador, conseguimos visualizar os produtos da companhia Apple, retornando apenas os nomes dos produtos, como iPhone e iPad.
- O código pode ser ajustado para incluir mais informações, como o id dos produtos.

## Conclusão
Nesta aula, aprendemos a criar um relacionamento entre companhias e produtos usando GraphQL, definindo o campo `produtos` e implementando a lógica para filtrar os produtos com base na companhia associada.

**Próximos Passos:** Continuar experimentando com adições e melhorias na nossa API.

Até a próxima aula!
```

Olá a todos vamos continuar aqui então vamos fazer o relacionamento para relacionar companhia a um produto
a nosso relacionamento é o seguinte uma companhia pode ter vários produtos
então nós temos aqui olha a query vai poder pegar todos os produtos mas nem todos os produtos
vem da mesma companhia agora o que a gente quer fazer é pegar o produtos de uma companhia específica
nesse caso aqui companhia com id1 me dê não somente o nome da companhia mas eu quero também todos os produtos dessa companhia
e quando você voltar a retornar os produtos eu só quero saber do nome
então vamos lá você vai aqui em cima essa aqui a nossa root query a query raiz a gente vai aqui para o tipo companhia
companhia type agora o campanha type tem vários o que produtos então aqui no campo nos na propriedade dos campos fios para
companhia nós vamos adicionar propriedade chamada produtos tá porque quando você bate na companhia está dentro da
olha aqui no lado esquerdo você vai escrever produtos esse cara aqui corresponde a esse campo que a gente criou no plural
então produtos vamos definir esse objeto qual é o tipo o tipo vai ser o que uma lista de produtos então vamos fazer
aquela mesma coisa se lembra qual é o grafql negócio para a lista olha aqui se lembra o grafql list então vamos usar a mesma coisa lá
vai dizer new graphql list mais lista de que de produto type esse cara aqui então vamos lá produto type
aí tá legal aí você está dizendo que é uma lista de produtos mas agora a gente tem que dizer o grafql como ele vai encontrar
esse produtos que ele não sabe então você tem que dizer que que propriedade qual é a propriedade que é uma função que você usa para
poder encontrar as coisas você vai usar o resolve tá resolve diz o grafql como é que você encontra esse recurso então para dar o resolve
vamos usar os argumentos parent value que é o primeiro e o segundo vai ser args vamos ver se a gente vai usar isso vamos dar o
resolve aqui só para você ver parent value e args cadê deixa eu dar o consola dos dois para você ver args vou retornar nada
o objeto vazio tá certo eu vou salvar ver se o servidor já atualizou aqui
desculpa eu tenho que dizer uma lista em vez do objeto porque isso é uma lista então aqui retorno a lista só para deixar isso funcionando
tá bom você nota produtos você tornou uma lista em branco vazia porque era isso que a gente vai retornar mas eu quero saber do consolo
olha que o consolo parent value você nota aqui tá retornando esse objeto com id1 e nome apple tá bom
e aí
então se você nota aqui o parent value vai retornar o id da companhia e a gente vai precisar desse cara para poder achar todos os produtos que
pertencem a companhia de id número um então por isso que a gente tem um parent value que é o pai né o valor do pai
que nesse caso é a companhia o objeto da companhia né então vamos dar esse cara para fazer a busca pelo todos os produtos cuja
companhia tem id a companhia de um vamos lá bota aqui no return a gente vai fazer o seguinte onde é que estão produtos
lembra os produtos se você lembra aqui a gente já fez esse query tá dentro dessa chamada de api simulada com essa função find produtos
se a gente for nesse arquivo da api tem find produtos mas não tem ainda a função sim para a gente poder encontrar o produto por id
então a gente pode adicionar um extra ou pode adicionar um argumento aqui opcional então vamos ver aqui produtos
vamos fazer um extra então vou fazer esse aqui é por causa da api simulada a gente tem que fazer vamos fazer find produtos
vai companhia id a companhia id aí você pega o id da companhia e essa função vai ser o seguinte tá
ela vai procurar aqui fazer uma busca e vai filtrar só os produtos que tem companhia id esse caso pode ser um por exemplo
como a gente só tem produtos com a opção id a que agora adiciona mais para poder realmente funcionar o negócio
o adicionar o 3 a da pixel o que é a companhia 3 o rm companhia 3 o microsoft companhia 2 google pixel o microsoft o d3
tá bom então deixa eu adicionar só mais uns aqui opa vou descer esse id xbox tá id 5
adicionei 3 novos recordes para dançar o banco de dados fácil para os produtos o pixel companhia id 2 o google o surface o xbox companhia id 3 o microsoft
então vamos aqui em baixo find produtos vai companhia id ele vai retornar uma nova promessa
promessa resolve reject como dois parâmetros pela sua função aqui dá o set time at para simular uma espera
300 mili segundos e vamos dar o que resolve do que vamos dar o resolve pega os produtos e filtra o produto onde o produto ponto companhia id
você só vai deixar passar os produtos que o companhia id seja o companhia id passado pelo argumento da função
ele vai pegar a gerar a nova lista e somente deixar passar os produtos cuja companhia é especificada
tá bom esse aqui é o nosso método simulado para poder obter os produtos pelo id da companhia
com esse escrito vamos voltar lá no nosso esquema
aí vamos lá fazer continuar aqui volta lá para o companhia type aí você vai dar o return do que vai chamar api ponto find produtos
o objeto vai companhia id e passa o id da companhia mas cadê o id da companhia se lembra que tem o parent value esse cara tem o objeto da companhia que tem o id
então você vai falar parent value ponto id que é o id da companhia tá e esse vai é tornar o novo promessa e essa promessa vai ser resolvida pelo resolve
ele automaticamente vai desembrulhar a promessa com o valor que é a lista dos produtos que pertencem a companhia com o id especificado
vamos salvar vamos ver no que dá vou atualizar o navegador agora você vê pra vou deixar o delta esse produto aqui
a deixei mesmo você vê que tem tem vários produtos olha na nossa query de produtos 5 né aí você não é como eu digo me dê companhia com o id 1 que a apple e eu quero só o nome da companhia tá aqui
agora quero também saber dos produtos da sua companhia mas só quero o nome só quero o nome dos produtos então apareceu aqui o iphone e ipad que tá correto se você olhar na lista de produtos está corretamente pareceu corretamente né
você quiser o id dos produtos só adicionar a ideia aqui ó e rodar de novo pareceu
tá
e se você esperar a gente adicionar mais
fios pois seria legal pra gente fazer mais experimento então é por isso é por essa aula é só vamos revisar
então a gente aprendeu a relacionar a companhia e produtos é bem fácil a companhia você adiciona um fio que é um campo chamado produtos nesse caso plural porque a companhia tem vários produtos
você faz a mesma coisa de antes como sempre qual é o tipo desse campo ah nesse caso vai ser uma lista então usa graphql list mas você passa o produto type que vai ser cada cada item dessa lista é de tipo produto
agora o graphql não sabe como é que acha esse produto então você tem que dizer ele com o método resolve que leva dois argumentos parent value args
nesse caso a gente usa só o parent value que nesse caso corresponde ao a companhia né o objeto da companhia e a gente usa parent value para poder pegar o id da companhia
para passar para esse método que a gente escreveu no back end api simulado para encontrar e filtrar todos os produtos pelo id da companhia
então a gente acha os produtos que pertencem a companhia especificada
tá
vamos por essa aula só e até a próxima


000f-13 Relacionando Companhia com Produto (1 para N / Um para Muitos no GraphQL)

Relacionando Produto com Companhia (Pertence a Um no GraphQL)

# Resumo do Transcript

Nesse vídeo, a discussão gira em torno do uso do GraphQL para trabalhar com produtos e as companhias associadas a eles. A seguir estão os principais pontos abordados:

1. **Introdução ao Assunto**:
   - O apresentador menciona que a companhia possui vários produtos.
   - A ideia é aprender a extrair dados da companhia associada a um determinado produto.
  
2. **Consulta de Dados**:
   - O apresentador sugere que se alguém tiver dúvidas ou quiser saber mais sobre produtos da companhia, pode comentar usando comandos específicos.

3. **Estrutura de Dados**:
   - Fala-se sobre a necessidade de adicionar um campo de companhia ao tipo de produto.
   - É mencionado que, ao fazer uma consulta, devemos usar o `find` para localizar a companhia pelo ID associado ao produto.

4. **Problemas e Resoluções**:
   - Um erro de referência ocorre porque a definição do tipo "companhia" vem depois da definição do tipo "produto".
   - A solução proposta é definir os campos como uma função que retorna um objeto, o que evita o problema de referência.

5. **Implementação**:
   - A implementação final resulta em uma consulta onde, para cada produto, a companhia associada pode ser recuperada, contendo informações como o nome da companhia (por exemplo, Apple, Google).

6. **Conclusão**:
   - O apresentador conclui o vídeo reforçando a ideia de que agora temos uma maneira de acessar a companhia associada a cada produto através de uma abordagem correta no GraphQL.

Este resumo destaca a essência da aula sobre como estruturar consultas em GraphQL para relacionar produtos e suas companhias.

olha o pessoal estamos de volta então companhia tem vários produtos né mas
agora a gente pega todos os produtos para acompanhar o tal mas e o post se você
tiver um produto que quiser saber mais detalhes da companhia
não é que faz deixa eu comentar aqui se você quiser comentar query só botar os
sinais da vela aqui ó esse caso é aperto comando barra para no maquete
comentar então se você tiver produtos por exemplo produtos aqui e tem companhia
e de mas não quero saber de companhia e de ninguém quer saber disso é o pruso
interno quero saber da companhia com a companhia desses produtos e agora não tem
como é que faz então vamos lá para o editor de texto então a gente tem
companhia tem vários produtos legal a gente fez isso mas agora a gente quer fazer o
oposto a sua ação reverso aqui é o produto
type tem a companhia a gente tem o companhia de aqui então vamos adicionar
companhia companhia como um campo agora qual o tipo desse cara e o tipo é
companhia né companhia type e mas o type está definido depois e agora vamos ver
o que dá o que dá o resolve desse cara
vamos ver vamos ver então você tem o produto que achar companhia desse produto
e onde é que tá a companhia tá na R&M aqui tem será que tem função já que a
gente escreveu para achar o produto e achar companhia pelo ID tem aqui ó você
pode achar companhia pelo ID com o find então a gente usa o companhia ponto find
da companhia então aquele lance de sempre que você tem que dizer ao
GraphQL como encontrar o recurso então para ir do produto para a companhia tem
que dizer o GraphQL tá certo eu tenho o produto o produto de companhia ID que é
o parent value ponto companhia ID o parent value aqui se lembra
então você vai chamar companhia ponto find com o ID do da companhia agora o
companhia esse produto tem companhia ID esse produto vai ser o parent value que é o
pai né então você vai da parent value ponto companhia ID
e isso coincide deve achar aquela companhia pelo ID você retorna isso
e salvar ver no que dá esse deu nenhum erro opa deu erro como a gente tinha
suspeitado antes tem um erro de referência porque companhia tá não tá definido
porque tá definido depois do prototype e agora como é que já faz esse negócio
e isso então tem uma maneira que de resolver isso é no fields em vez de você
definir com o objeto você vai definir esse cara como a função que retorna um
objeto esse objeto inteiro vai ser retornado de uma função só adicionar aqui
ó as parentes e as flechas aqui é certo então esse cara agora é uma função e
retorna um objeto tá por causa de um objeto tome cuidado e que adicionar o
sinal parentes aqui para indicar que é um objeto e não o bloco de função tá
então adicionar os parentes aqui cobrindo esse objeto vamos ver se prestou
já até pumping reuni muitos tipos cl игры que iam nessa que befica
o caso não sinal crystallizada aqui ainda vamos sairetos afö Upon
Então você sempre tem que ter pelo menos uma.
Vamos passar o nome, acompanha.
Tá aí então.
Olha aqui.
Você note que agora a gente pegou os produtos.
Não só o idê e o nome do produto, mas a companhia do produto.
Companha e pega o nome.
Apple, Apple, Google, assim por diante, tá?
Então é isso. A gente fez a...
Operação, post.
Então antes a gente tinha companhia,
queria pegar todos os produtos dessa companhia.
Agora a gente tem os produtos.
E para cada produto, você quer pegar a companhia do produto.
Para usar isso, a gente...
Pô, lá no produto type, adicionou a field companhia.
Type, companhia, type, e deu o resolve para dizer o GraphQL.
Como é que acha essa companhia?
Só para lá, companhia find pelo idê, que está dentro do objeto do produto.
Companha e idê.
Agora a gente teve o problema porque companhia e type
só foi definido depois da definição do produto type.
E não antes.
Aí deu problema de referência.
Para resolver isso, você muda o fields e em vez de ser só um objeto,
você muda ele para um tank, né?
Que é, na verdade, uma função...
Ah, não é tank nesse caso, é só uma função mesmo.
Função que retorna um objeto, tá?
Note que tenho parênteses aqui.
Vai significar que esse está retorno no objeto,
isso que não é bloco de função.
Tá bom?
Eu retorno implícito.
Por essa aula só, e até a próxima.


000f-14 Relacionando Produto com Companhia (Pertence a Um no GraphQL)

Root Query de GraphQL para Encontrar Produto Por Id

# Resumo da Transcrição

Na transcrição, o objetivo é criar uma consulta (query) para buscar um produto pelo seu ID, utilizando GraphQL. O passo a passo é o seguinte:

1. **Estrutura da Query**: A consulta deve ser semelhante àquela usada para buscar uma companhia por ID.
2. **Implementação**:
   - A consulta começará na `root query`, que é a consulta raiz.
   - Um novo campo chamado `produto` será adicionado à `root query`, que aceitará um argumento `id`.
   - O tipo desse campo será `produto type`.

3. **Definição de Arguments**:
   - Os argumentos incluirão o `id`, que será do tipo `GraphQL Int` e não pode ser `null`.
   - A função de resolução (`resolve`) irá usar o `id` para encontrar o produto correspondente.

4. **API e Resolução**:
   - A API simulada precisará de uma função `findProduct` para buscar o produto pelo ID.
   - Dentro da função `resolve`, será necessário chamar a função API e passar o `id` que foi recebido dos argumentos.

5. **Execução e Teste**:
   - Após salvar as configurações e reiniciar o servidor, a consulta será testada para garantir que retorna o produto correto.
   - Mensagens de erro são tratadas, e ajustes no código (como adicionar vírgulas) são realizados para garantir o funcionamento correto.

6. **Verificação dos Resultados**:
   - O sistema de GraphQL permite verificar facilmente os tipos e as queries disponíveis, tornando o processo de desenvolvimento mais interativo.

No final, a implementação do produto por ID funcionou, e o usuário teve acesso aos detalhes do produto, como nome e companhia.

## Conclusão
A aula ensinou como criar uma consulta GraphQL simples para buscar um produto por ID, abordando desde a definição do esquema até a execução da consulta e tratamento de erros.

Nós vamos fazer uma query para pegar um produto por id.
Vai ser a mesma maneira que a gente já fez para pegar um companhia por id.
Eu quero ver você fazer primeiro, tenta fazer.
Agora eu quero fazer a seguinte query, produto, passo id,
e pega o nome do produto, e quero o companhia, me deu id, o nome da companhia.
Eu quero que você faça essa query aqui.
Pause o vídeo e depois a gente continua.
E aí deu tudo certo. Vamos lá.
O recurso é produto, vai ser lá no produto.
Vai ser a root query primeiramente, porque está dentro do query, que é a query-raiz.
Então vai ter que adicionar um campo da root query chamado produto,
que leva como argumento o id.
Vamos lá, de volta ao esquema.js, aqui embaixo no root query type.
Os campos têm companhia plural, companhia singular, produtos plural,
mas não tem produto no singular.
Então você adiciona aqui a chave, produto, qual é o tipo, produto type.
E agora, como é que fala o resolve?
Tem também o args, se lembra?
Porque a gente tem que dizer o id.
Args tem o id que você vai passar, tipo o quê?
É um GraphQL int, mas não pode ser no.
Então fala em you, GraphQL, non, no,
passa o GraphQL int como argumento.
Então, produto vai ser tipo produto type.
Argumentos têm um id que é tipo um GraphQL int inteiro, que não pode ser no.
Então no resolve você vai dizer como encontrar o produto.
Nesse caso é por id.
Então o produto está na API, vamos olhar o api.index.js,
tem findProducts plural, tem findProducts por companhia id,
mas não tem o api simulado para encontrar o produto por id.
Então vamos adicionar aqui, findProduct no singular e vou adicionar o id do produto.
E é bem fácil retornar de novo.
New Promise, resolve, reject, sempre assim.
Então set time out para simular o espera.
Nesse back end simulado, essa API simulada, se pedir simulado, resolve com o quê?
A gente vai lá bater nos produtos, find o produto cujo
produto.id é igual o id passado como argumento pela função.
Então é isso, você vai encontrar o produto, o id é argumento.
Se não encontrar, vai retornar no, tá?
Salvar, então vamos dar o findProduct da API.
Para dizer o GraphQL como encontrar o produto, vai dizer retorne.
api.findProduct, qual o id?
Agora o id está vindo do args, para pegar esse, o segundo argumento do resolve.
Primeiro apparent value, o segundo é args, que é os argumentos passados.
Então você vai usar args.id.
Então é isso, salvar, vamos lá tentar novamente.
O servidor já reiniciou porque eu estou usando node.mon.
Então vou dar a query aqui, opa, deu problema.
Vamos ver o que deu.
resolve unexpected identifier, será que eu esqueci uma vírgula?
Eu esqueci a vírgula aqui depois do args, eu adiciono a vírgula, salvar,
reiniciou, então deixa eu comentar o primeiro produto
e eu quero só ver nessa query produto por id.
Então pegou o produto, nome iPad, companhia, Apple, tá certo?
Vamos tentar o produto de id 4.
Tá aí, surface, companhia id 3 Microsoft,
vai adicionar o id do produto para conferir.
Tá aí, id 4 mesmo.
Então você pediu o produto por id, essa chave produto é um field do campo da root query,
o argumento args.id aqui, 4, que é um GraphQL int.
Tem até esse negócio legal aqui, se você dá o hover,
deixar o mouse aqui, você pode clicar na root query type, ele te diz as queries
que você pode fazer nos campos da root query type.
Tem o companhia, você clica no produto, ele te mostra os fields.
Isso é legal, do GraphQL aqui.
Tem até o tipo int, o que é que é int.
Você clica em produto, ele vai lá, leva o argumento id, e esse produto é uma lista de produtos.
Companhia você vê aqui as coisas, que tem vários produtos.
Muito legal para você ver o seu esquema aqui.
Então para essa aula só e até a próxima.


000f-15 Root Query de GraphQL para Encontrar Produto Por Id

Adicionando Mais Campos (Fields) ao Recurso Produto no GraphQL

```markdown
# Resumo da Aula de GraphQL

Na aula, o instrutor adiciona novos campos ao recurso "produto" e ao recurso "companhia" em um esquema GraphQL.

## Adições ao Recurso Produto

1. **Consulta GraphQL**: O instrutor começa com uma consulta para buscar um produto por ID, retornando seu ID e nome. Exemplo: o iPhone, que pertence à Apple.
   
2. **Novos Campos**:
   - **lançado_em**: Adicionado como uma string que representa a data de lançamento (formato: AAAA-MM-DD).
   - **imagem**: Adicionado como uma string, que será a URL da imagem do produto.

3. **Modificação no schema.js**:
   - No arquivo `schema.js`, os campos `lançado_em` e `imagem` são adicionados ao tipo de produto, utilizando o tipo `GraphQLString`.

4. **Atualização do banco de dados**:
   - As informações de `lançado_em` e `imagem` são adicionadas a cada produto na lista que retorna da API (arquivo `api/index.js`).
   - Por exemplo:
     - iPhone: "2007-06-29"
     - iPad: "2010-04-03"
     - Pixel: "2013-02-21"
     - Surface: "2012-10-26"
     - Xbox: "2001-11-15"
   - URLs das imagens são coletadas de fontes como Wikipedia e Wikimedia.

## Teste das Mudanças

Depois de adicionar os novos campos, o instrutor verifica no GraphQL se as informações de `lançado_em` e `imagem` estão aparecendo corretamente ao fazer consultas pelos IDs dos produtos.

## Vantagens do GraphQL

O instrutor destaca que uma das principais vantagens do GraphQL é seu recurso de solicitar apenas os dados necessários. Isso ajuda a:
- Reduzir o uso de banda, especialmente útil para usuários em dispositivos móveis com conexões lentas.
- Melhorar a eficiência das chamadas a APIs, evitando o envio de dados desnecessários.

A aula termina com a ênfase na utilidade do GraphQL para pedidos de dados mais precisos e eficientes.

---
**Próximos passos**: Os alunos são incentivados a praticar a adição de campos e testar as consultas por conta própria antes da próxima aula.
```

Estamos de volta, vamos continuar nesta aula, vamos só adicionar mais campos adicionais
ao recurso companhia e ao recurso produto.
Começando aqui com o produto, eu tenho essa query no GraphQL, que ficou aqui, por um
produto, buscar o produto por id e retorne, por favor, o id e o nome, neste caso retorne
o iPhone, acompanha a Apple.
Então vamos adicionar os seguintes campos.
Primeiro, uma data de lançamento, campo para data de lançamento que eu vou chamar de lançado
em e outro campo, uma URL da imagem do produto que eu vou chamar de imagem.
Lançado em vai ter o formato de ano, prazo, mês, prazo, dia, mas a gente não precisa
preocupar se for data ou não, isso aqui é só uma string, então você faz lançado em
com formato string.
Mesma coisa para imagem, formato string, com HTTP e assim por diante.
Então, quero ver você adicionar esses dois campos, as duas fields, né, ao recurso produto
lá no arquivo schema.js, para os vídeos tenta fazer por si próprio e depois a gente
continua juntos.
Vamos lá então, voltando ao editor de texto, no arquivo schema.js temos o esquema aqui
para o produto type, já temos as fields, né, os campos de id, de nome, companhia id
e a relacionamento com a companhia também, depois de nome vamos adicionar lançado em,
lançado em, o tipo desse campo será graph, que é o string, é uma data mais é só uma
string, o outro campo é para URL da imagem, é só adicionar imagem, um objeto, type,
graph, que é o string, também é uma string.
Com isso a gente salva o arquivo, mas se você der a query de novo ele vai pegar no, porque
o nosso banco de dados simulado ainda não tem definido essas propriedades para cada
recorde do produto.
Então, vamos fazer isso agora, se lembra que o produto vem do arquivo api, barraindex.js,
temos essa lista aqui, produtos e vai ser retornada pelos nossos métodos aqui da api.
Então, a cada objeto aqui eu vou adicionar o campo lançado em e imagem.
Vamos começar com lançado em, então eu vou selecionar tudo de uma vez aqui, vou começar
aqui, vou dar uma virgula e vou adicionar lançado em, vou adicionar duas aspas e agora
vou digitar para cada uma data de lançamento do produto e já preciso ir aqui primeiro
para o iPhone, 2007 traço 6 traço 29, 2007 traço 06 traço 29, o iPad, 2010 traço
04 traço 03, o Pixel, 2013 traço 02 traço 21, o Surface da Microsoft, 2012 traço
10 traço 26, eu peguei essas datas da Wikipedia, espero que estejam certas, embora que é
só, se você não quiser perder tempo com isso pode colocar a data, Xbox 2001 traço 11
traço 15.
Tá bom?
Agora vamos fazer para imagem.
Vou fazer a mesma coisa relacionar esse, esse e esse, virgula, imagem, duas aspas
individuais, agora para o produto eu peguei, tenho aqui um arquivo que eu peguei o link
ao RL de cada imagem do produto que eu achei na Wikipad, na Wikimedia, essa é a fonte
dessas imagens, você pode usar qualquer imagem que você quiser também, é só para a gente
ter alguma coisa lá na propriedade, vou começar aqui com o iPad, vou copiar, colar aqui
o iPad, o iPhone, fazer um pulo, copiar o Surface, o Pixel, e, finalmente, o Pixel,
o Xbox, o VD5, tá, então é isso, adicionamos a propriedade lançada, propriedade imagem
a cada produto aqui.
Então vamos tentar novamente no graphical, ver se dá alguma coisa, apareceu para o produto
de D1 lançado em, e a imagem, vamos tentar ID2, o iPad, ID3, Pixel, ID4, Surface, ID5,
Xbox, certo?
Vamos a gente aprender o GraphQL você pode pedir exatamente os dados que você quer,
se você não precisar do nome do produto é só remover e ele não manda mais o nome,
se você não precisar mais do dado do lançamento é só remover e ele não manda mais, e assim
por diante, só escolher os campos que você quer, receber no front end, tá, isso ajuda
muito especialmente os usuários que estão no dispositivos móveis com a internet,
com conexão que é bem devagar em comparação a sua internet de caso, então eles não
precisam receber, se ele recebeu muita informação vai demorar um pouquinho para receber resposta
do servidor e se tiver algum meio que é o GraphQL de mandar menos informações, manda
as informações necessárias porque em muitos casos as APIs mandam muita informação e você
acaba nem usando todas as propriedades que são enviadas pela resposta, então o GraphQL
você pede exatamente o que você vai precisar para mostrar no front end, então é só selecionar
os campos necessários e ele só vai mandar aquilo, você vai ter desperdício da banda,
da conexão, o usuário também pode ter conexão limitada com limite de dados, então tem vários
fatores, aumenta a velocidade e deixa tudo bem melhor, tá, então por essa aula é só e até a próxima.


000f-16 Adicionando Mais Campos (Fields) ao Recurso Produto no GraphQL

Adicionando Mais Campos (Fields) ao Recurso Companhia no GraphQL

# Resumo da Transcrição

Nesta transcrição, o autor discute como aprimorar um recurso de "companhia" em um banco de dados, adicionando novos campos à estrutura. A seguir estão os principais passos e informações abordados:

## Adição de Campos ao Recurso Companhia
- **Objetivo**: Adicionar campos como "data de fundação" e "site" à entidade "companhia".
- **Dados de Exemplo**:
  - Google como uma companhia com ID 2.
  - Campos a serem adicionados:
    - `fundada em`: tipo GraphQL string.
    - `site`: URL da companhia também como GraphQL string.

## Procedimentos 
1. **Erro Inicial**: A busca falhou porque os novos campos ainda não estavam definidos.
2. **Definições**: 
   - No editor, foi criado um novo tipo GraphQL para a companhia.
   - Adicionaram-se os novos campos `fundada em` e `site`.
   
3. **Banco de Dados Falso**:
   - Modificações feitas no arquivo `ORM/companhia.js` onde uma lista de objetos representa cada companhia.
   - Exemplo de dados adicionados:
     - Apple: 
       - Fundada em: 1976-04-01
       - Site: `http://www.apple.com`
     - Google: 
       - Fundada em: 1998-09-04
       - Site: `http://www.google.com`
     - Microsoft:
       - Fundada em: 1975-04-04
       - Site: `http://www.microsoft.com`

## Conclusão
- Após a adição das informações, uma nova query pode ser feita para verificar se os campos foram corretamente implementados. Os campos podem ser personalizados conforme necessidade, demonstrando a flexibilidade do GraphQL.

## Nota Final
- A aula termina com a ideia de que é simples manipular os dados utilizando GraphQL conforme a necessidade do usuário.

Então adicionamos os campos lançado em imagem ao recurso produto.
Agora vamos trabalhar no recurso companhia, vamos adicionar por exemplo, vamos fazer uma
query para a companhia aqui, pegar a companhia de id2, quero id e o nome da companhia.
Note que nesse caso é Google, vamos adicionar duas fields a esse curso.
O primeiro field vai ser a data de fundação da companhia, fundada em, vou chamar de fundada em
e vou adicionar o site, que é o URL do site da companhia.
Então a gente ainda não tem isso, por isso que deu erro, não deu para fazer busca do
campo, fundada em query e o site no tipo companhia, porque não tem.
Então quero ver se adicionar essas duas fields ao recurso companhia, pause o vídeo e faça
para o seu próprio e vamos ver.
Ele deu certo, vamos lá, no editor de texto, voltando a arquivos que o meu pote js, já
fizemos o produto type, agora é hora de fazer companhia type.
Já temos o id e o nome, agora vamos adicionar fundada em, que é só uma data que na verdade
é um GraphQL string.
E finalmente para o site, a mesma coisa, type GraphQL string.
Com isso a gente salva, está lá no GraphQL, os valores são no por que nosso banco de
dados simulado ainda não tem, essas propriedades.
Então vamos adicionar, certo, vamos lá.
O banco de dados falso da companhia está dentro do arquivo ORM barra companhia.js, que no
começo você tem uma lista de objetos com cada objeto sendo uma companhia.
Então vamos adicionar cada companhia aqui, eu vou selecionar a multiplaçação, vou
adicionar primeiro a propriedade de fundada em com uma string e vou adicionar a outra
que é o site, mesma coisa, duas áspias.
Então vamos lá, para a Apple vai ser aqui 1976, traço 04, traço 01, para Google, 1998,
traço 09, traço 04, Microsoft, 1975, traço 04, traço 04.
Então peguei esses valores da Wikipedia, espero que estejam certos, senão é só colocar qualquer
dato que você quiser.
Agora para o site, vamos fazer lá, http www, Apple.com, todos são o .com, quase a mesma
coisa, só copiar e colar e mudar essa palavra.
Está bom?
Então é isso, adicionamos a data de fundação, fundada em e o site.
Salvar, fazer outra query, agora aparece, dá lançado, oh desculpa, essa query aqui,
companhia, nome da companhia, fundada em e o site.
Se você não quiser esses caras, só remover, graphQL, faz tudo, te dá o que você quiser.
Não quer o ID, só dado a fundação, o site, certo?
Vora essa aula é só, até a próxima.


000f-17 Adicionando Mais Campos (Fields) ao Recurso Companhia no GraphQL

Alias na Query do GraphQL (Buscando múltiplos recursos, mas não todos)

# Aula sobre Queries Nomeadas

Na aula de hoje, aprendemos sobre **queries nomeadas** e como consultar informações de múltiplas companhias simultaneamente.

## Tópicos abordados:

- **Consultar várias companhias**: 
  - Exemplo: Informações sobre a companhia com ID1 e ID3.
  
- **Erro na consulta**:
  - Ocorre um conflito de campos ao tentar consultar diferentes IDs simultaneamente, resultando em uma mensagem de erro.

- **Solução com aliases**:
  - Para resolver o conflito, é necessário utilizar **aliases** para cada consulta.
  - Exemplo de uso de aliases:
    - Para a companhia com ID1, podemos usar `Apple` como alias.
    - Para a companhia com ID3, utilizamos `Microsoft`.

## Exemplo de consulta:

```graphql
{
  Apple: company(id: "ID1") {
    name
    founded
  }
  Microsoft: company(id: "ID3") {
    name
    founded
  }
}
```

### Observações importantes:

- **Como funciona**:
  - O resultado da primeira companhia aparecerá sob a propriedade `Apple`, e da segunda sob `Microsoft`.
- **Prefixo de consulta**: Para cada query, utilize o nome do alias seguido de dois pontos, como prefixo.

## Conclusão

Utilizar aliases é essencial para realizar queries de diferentes companhias sem conflitos. 

Até a próxima aula!

Fala pessoal, estamos de volta nesta aula, nós vamos falar de queries nomeadas.
Vamos aprender como fazer a query de, por exemplo, duas companhias ao mesmo tempo.
Estamos aqui no gráfico, o gráfico ficou aqui, temos uma query já, então vamos supor
o que você quer saber informações da companhia de ID1, ID1, ID1, ID1 nome, e é lançado,
opa, fundada aí.
Mas você também quer saber informações da companhia de ID3, como fazer isso?
Vamos tentar fazer outra query aqui ao mesmo tempo, ID3, ID, me deu nome, fundada em,
da problema.
Então está dizendo a mensagem de erro aqui, que os campos, companhia estão em conflito,
porque em argumentos diferentes, então está dizendo, use aliases diferentes, se você realmente
quiser fazer essa operação.
Então para poder fazer essa query assim, a gente quer informação da companhia de ID2, mas
também da companhia de ID3, para poder fazer isso você vai adicionar aliases, para poder
fazer isso é o seguinte, você vai aqui, antes dessa fio aqui que você fala aqui, você
põe o nome da eles.
Então eu não sei qual essa companhia deve ser Apple, vamos botar aliases Apple.
E dessa outra companhia deve ser Microsoft, vamos botar aliases Microsoft.
Então agora funciona.
Então você note aqui que o primeiro objeto que é a companhia de ID1, é retornado dentro
de um propriedade chamado Apple, que eu defini nessa ele, isso aqui.
Então a ele você bola o nome, seguido de dois pontos e a sua query normalmente assim,
a seu campo, seu field.
Mas eu sabia que já era Apple, mas normalmente ele não sabe, né?
Então sei lá, fala primeira companhia, sei lá, range 1, nomeação aí.
Mas só queria ilustrar aqui, para poder você buscar várias companhias diferentes por
ID você pode acionar as se eles.
Nome do ele, seguido de dois pontos, como prefixo para cada uma dessas queries com o
mesmo field.
Tá?
Então é isso.
Nomeação alias, né?
Tá bom?
Então por essa aula é só e até a próxima.


000f-18 Alias na Query do GraphQL (Buscando múltiplos recursos, mas não todos)

Nomeando Queries no GraphQL (Definindo uma Query com Nome)

# Resumo da Aula sobre Nomeação de Queries

Na última aula, discutiu-se o uso de alias em queries, e nesta aula o foco é na nomeação de queries. Aqui estão os principais pontos discutidos:

1. **Nomeação de Queries**:
   - É possível dar nomes às queries, como "obter duas companhias" ou "obter todas as companhias".
   - Cada query pode ter seu próprio nome, facilitando a identificação e o uso posterior.

2. **Execução de Queries**:
   - Ao usar o GraphQL, você pode executar uma query específica. Por exemplo, pode escolher entre obter todas as companhias ou apenas duas.
   - Apenas uma query pode ser processada por vez em um pedido.

3. **Separação de Queries**:
   - A separação de queries facilita a organização, especialmente no front end, onde você pode definir suas queries em um arquivo e reutilizá-las posteriormente.
   - Embora não seja muito útil no contexto atual, onde se utiliza o GraphQL, essa prática ajuda na organização e reutilização de código.

4. **Benefícios**:
   - Mesmo que no contexto atual não pareça essencial, a nomeação contribui para um código mais organizado e reutilizável no desenvolvimento front end.

A aula conclui com um agradecimento e um convite para a próxima sessão.

Olá pessoal, estamos de volta na última aula que eu tinha falado da uso das alias, na verdade
essa aula que era falar da realmente da nomeação de queries, então eu tinha falado na nomeação
mas na verdade era o uso de alias.
Agora aqui a gente vai falar da nomeação de queries e na query aqui você tem a query
tem essa chave, mas entre esses caras eu vou dar o nome a essa query, por exemplo, obter
duas companhias.
Então funciona do mesmo jeito, então você pode dar o nome a suas queries dessa maneira
aqui, por exemplo, tem um obter todas as companhias, essa query aqui também.
Eu posso dar companhias, e se eu quiser o ID, se quiser o nome, fundada em e que mais?
site.
Então, você note aqui agora tem duas queries.
Então, você nomeou as suas queries, agora tem duas queries, tem a query de obter todas
as companhias, tem a query de obter só duas companhias.
Então quando você clica no botão de play, no caso do graphical, você tem a opção
de rodar essa query para obter duas companhias, ou obter todas as companhias.
Agora você só pode fazer uma query por cada pedido, então por isso que tem que escolher
uma das duas.
São as queries separadas, se você quiser incluir todas as companhias nessa query,
teria que pegar esse cara aqui e pôr aqui dentro.
Mas como esse não é o meu objetivo, eu separo elas.
Mas por que separar essas queries?
A separação das queries é mais útil para o front end.
Quando você está lá no front end, você vai definir as suas queries num arquivo, por
exemplo, e você nomeia elas para poder reutilizá-las depois, você importa a query e usa a query
para poder buscar esses dados.
Nosso caso aqui não é muito útil porque a gente está usando o graphical, mas senó
que deixa as coisas mais organizadas e vai ser muito útil no front end.
Então você pode nomear essas queries dessa maneira aqui.
A bom, presta alessado e até a próxima!


000f-19 Nomeando Queries no GraphQL (Definindo uma Query com Nome)

Como Criar Fragmentos Fragment para Incluir na Query (Aula Tutorial do Curso de GraphQL)

# Resumo da Aula sobre Fragmentos

Nesta aula, abordamos o conceito de fragmentos em consultas (queries). Observamos que, frequentemente, repetimos as mesmas propriedades em diferentes consultas. Para evitar essa repetição, usamos fragmentos para reutilizar listas de propriedades.

## Conceito de Fragmentos

Fragmentos permitem definir um conjunto de propriedades que podem ser reutilizadas em diferentes consultas. Por exemplo, se em todas as consultas queremos incluir `id` e `nome` de uma companhia, podemos criar um fragmento.

### Exemplo de Criação de Fragmento

1. **Definição do Fragmento:**
   - Palavras-chave: `fragment`
   - Nome do fragmento: `campos básicos da companhia`
   - Tipo do recurso: `companhia`
   - Propriedades: `id` e `nome`

   ```graphql
   fragment campos básicos da companhia on companhia {
     id
     nome
   }
   ```

2. **Uso do Fragmento:**
   Para usar o fragmento em uma consulta, basta adicionar `...` seguido do nome do fragmento:

   ```graphql
   {
     companhia1: companhia(id: 1) {
       ...campos básicos da companhia
     }
   }
   ```

### Aninhamento de Fragmentos

É possível criar fragmentos que incluem outros fragmentos. Por exemplo, podemos criar um novo fragmento chamado `campos básicos com fundação da companhia`, que inclui `id` e `nome` de `campos básicos da companhia`, além da propriedade `fundado em`.

```graphql
fragment campos básicos com fundação da companhia on companhia {
  ...campos básicos da companhia
  fundadoEm
}
```

### Exercício Proposto

- Experimente criar um fragmento que inclua a propriedade `fundado em`, utilizando um fragmento anterior. Ou, crie um novo fragmento para esta funcionalidade.

## Conclusão

Os fragmentos são uma ferramenta poderosa para reutilizar código em consultas GraphQL, facilitando a manutenção e a legibilidade. Experimente diferentes combinações e estruturas de fragmentos. Até a próxima aula!

Tamos de volta, nesta aula vamos falar de fragmentos.
Então, você note que, por exemplo, nós temos duas queries, né?
E cada query tem esta regala de companhia 1, companhia 3, tem este.
Note que a gente sempre quase fala as mesmas coisas.
E D não me fluidada N, e D não me fluidada N, e D não me fluidada N.
Então, não teria um método para a gente reutilizar este cara e falar só uma coisa
em vez de ficar se repetindo várias vezes.
Então, para isso que serve os fragmentos.
A gente vai definir fragmentos para poder reutilizar uma lista de propriedades
quando a gente faz a nossa queries.
Então, por exemplo, vamos supor que a gente sempre dá diz,
e D nome, e D nome, e D nome.
E este é o detalhe básico da companhia. A gente pode fazer um fragment.
Olha só, vou adicionar aqui a palavra-chave fragment.
Vou ter que dizer o nome deste fragment.
Vamos dizer campos básicos da companhia.
Pode nomear qualquer maneira que você quiser.
Aí você fala on e o recurso, companhia.
Aí abre as chaves e põe as propriedades que você quer reutilizar a lista,
e D nome.
Então, este é o nome do fragmento campos básico da companhia
on o nome do recurso, neste caso companhia, o tipo.
As propriedades que você quer copiar e reutilizar.
Por exemplo, estou aqui nessa query, obtendo duas companhias, e tem esse companhia ID1.
Eu não quero digitar ID e nome de novo aqui, eu posso fazer o seguinte.
Eu ponho o nome do fragmento, campos básico da companhia,
e adiciono o prefixo de três pontos.
Então, ele vai copiar propriedades desta fragmento, que nesse caso o ID1, o ID e o nome,
e vai pôr aqui e vai dar na mesma, tá?
Vou rodar duas companhias.
Na hora de que apareceu o ID e o nome, da mesma maneira.
E assim eu posso fazer para cá e para cá, quero ver você fazer aí.
E aí, vamos lá.
Em vez de digitar ID e nome de novo, você vai falar três pontos, o nome do fragmento.
Mesma coisa aqui, três pontos, o nome do fragmento.
Agora ele vai copiar o ID e o nome deste fragmento e vai substituir aqui em cada uma dessas queries.
Eu estou aqui, tá? Olha o ID e o nome.
Tá?
Esse é o fragmento. Você pode fazer vários fragmentos e reutilizar a lista de parâmetros,
em vez de digitar eles toda vez.
Se você quiser, por exemplo, mais um exercício, olha que o fundado está aparecendo aqui.
Você pode incluir isso numa fragmento, pode até usar esse fragmento,
ou pode fazer outro fragmento, se você quiser.
Por exemplo.
Fragment, mas eu estou fazendo fragmento.
Campos básico com fundação da companhia.
On, companhia.
Vamos ver se dá até para copiar os propriedades do fragmento aqui.
Três pontos, campos básicos da companhia e a adiciona fundada em.
Em vez de falar esses caras aqui, você pode falar esse fragment.
Vamos ver se funciona mesmo.
Tá, então funcionou aqui.
ID, nome, fundado em.
Então, o que é que eu fiz? Eu vou ter um fragmento dentro de outro fragmento.
Em vez de pôr fundado em aqui, que você poderia fazer, isso também está certo.
Eu queria só ilustrar que você pode botar fragmento dentro de outro fragmento.
Tem esse fragmento chamado básico com fundação da companhia,
que inclui as propriedades do fragmento campos básicos da companhia, que é o ID e o nome.
E, além disso, inclui a fundada em.
E eu fiz aqui, ó, copiar as propriedades do básico com fundação da companhia e apareceu aqui.
Tá.
Então, deixe como exercício para você usar...
fazer esperimentos com esse fundado em e outros aqui.
Então, pode adicionar aqui e usar só um fragmento,
ou pode criar um novo fragmento que copia de outro fragmento.
Tá, só come exercício.
Então, por essa aula é só e até a próxima.


000f-20 Como Criar Fragmentos Fragment para Incluir na Query (Aula Tutorial do Curso de GraphQL)

Atualizando nosso Banco de Dados Simulado com Métodos para Criar Recursos (Companhia)

# Resumo da Aula sobre Mutações no GraphQL

Na aula de hoje, focamos na preparação para aprender sobre mutações (mutations) no GraphQL, essencial para atualizar bancos de dados e APIs. Especificamente, implementamos métodos para criar recursos, começando com a criação de uma companhia.

## Passos para Criar uma Companhia

1. **Método de Criação**:
   - Adicionamos o método `create` ao nosso modelo simulado no arquivo `ORM/companhia.votjs`.
   - Esse método aceita um objeto que representa a companhia, contendo as propriedades necessárias: `nome`, `fundadaEm`, e `site`.

2. **Implementação do Método**:
   - Retornamos uma nova promessa, onde utilizamos um `setTimeout` para simular uma espera de 300 milissegundos.
   - Criamos uma variável `últimoID`, que mantém o controle do último ID utilizado.

3. **Adicionando a Nova Companhia**:
   - Usamos `companhias.concat` para adicionar a nova companhia à lista existente.
   - Incrementamos o `últimoID` sempre que uma nova companhia é criada, definindo o ID da nova companhia como `últimoID + 1`.

4. **Retornando a Resposta**:
   - Após a criação, retornamos a nova companhia para o cliente, usando `resolve`.

5. **Validações**:
   - Não implementamos validações neste exemplo, assumindo que os dados são sempre enviados corretamente.

## Próximos Passos
Na próxima aula, iremos implementar a criação de um produto, seguindo um raciocínio semelhante ao que utilizamos para a companhia.

---

> **Nota**: A ordem dos passos pode variar, mas o fluxo básico é a inicialização do método, a manipulação da lista de companhias, e o retorno da nova companhia como resposta.

Estamos de volta nessa aula. Nós vamos em preparação para aprender sobre mutações,
mutations no GraphQL. A gente tem que atualizar nosso banco, nosso API e ORM simulado para
poder ter métodos para criar recursos, nesse caso criar uma companhia ou criar um produto.
Então vamos fazer isso nessa aula. Voltamos ao editor de texto aqui. Então vamos fazer o seguinte,
primeiro vamos começar com companhia. A gente já viu que para aprender, por exemplo,
você pegar a lista de companhias, você fala assim, companhia.find. A gente criou esse método no
nosso modelo simulado, companhia aqui que está no arquivo ORM, barra companhia.votjs,
que tem o banco de dados simulado seguido dos métodos. Nesse caso vai encontrar,
obter todas as companhias, find all, obter uma companhia por id. Agora a gente vai fazer o
create para poder criar uma companhia. Então vamos lá. Aqui depois do find vamos adicionar
create. E nós vamos criar, basear no objeto que é dado como argumento a essa função aqui. Vamos
pegar um companhia como objeto. Ele vai ter várias propriedades nesse caso, vai ter id, não tem id,
o que a gente faz aqui. Vai ter nome, fundada em e e os outros propriedades,
fundada em site. Então esses três vão ser necessárias para criar uma companhia.
Então vamos supor que esses caras são passados como objeto e como esse parâmetro aqui.
Aí o que a gente vai fazer? Primeiro de tudo vamos sempre retornar a promessa. Então vamos fazer
aquela mesma coisa. Vamos retornar uma nova promessa. Faço uma função aqui, essa função,
vamos definir os dois parâmetros resolve e reject. Vamos dar um set time out para simular uma espera.
Eu vou usar 300 milis segundos. Agora vamos definir como adicionar uma nova companhia. Se você olhar lá
em cima a gente tem essa lista de companhias que a gente definiu com let. Para poder adicionar uma nova
companhia você vai fazer o seguinte, você vai pegar essa lista e adicionar um outro cara ao final.
E também a gente tem que aprender a verificar como pega o ID, como gerar um ID. Para gerar o ID
a gente vai usar uma variável aqui fora para saber qual foi o último ID que foi criado.
Então vamos fazer o ID, o negócio do ID. Vamos criar a variável aqui, let, último ID. Agora esse
último ID vai corresponder a o ID do último recorde que foi criado. Nesse caso tem o ID 1, 2 e 3.
3 é o último recorde, então o último ID vai ser 3. Então quando a gente for criar a nossa nova
companhia vamos adicionar essa lista e setar o ID para o último ID mais um. Não se esqueça de
atualizar o último ID aqui. Então vamos lá. A gente vai fazer o seguinte, pega a lista de companhias,
vamos setar esse cara para companhias.comcat, a companhia que foi dada com o argumento.
Não tem nenhuma validação esse negócio aqui. O que a gente vai só fazer aqui no simulado, vamos
supor que sempre os dados estão sendo enviados corretamente, validados, tá? Então ele vai pegar,
criar uma nova lista e adicionar essa nova companhia a lista de companhias. Mas não tem o ID. Então
se você não vai poder fazer o ID, vamos fazer o seguinte, eu vou colocar o objeto aqui e vou
copiar as propriedades da companhia que foi passada e adicionar o ID. Agora para o ID, vamos fazer o
seguinte, pega lá o último ID e seta para o último ID mais um para poder incrementar e usa esse
último ID aqui, tá? Quando você fizer isso, o último ID, nesse caso, se você iniciar com
aqueles três objetos, será o último ID 1, 2, 3, 3 mais 1 é 4. Então o último ID será 4 e o
ID dessa nova companhia será 4. Tá bom? E finalmente, quando você fizer isso, como resposta
a Frontend, você vai retornar ao cliente, nesse caso, a companhia. Na verdade você tem que retornar
normalmente a companhia que foi criada, então esse objeto aqui. Então vou extrair uma variável,
recortar, vou dizer nova companhia, vou criar uma variável nova companhia, ponho o objeto dentro
dessa variável e retorna a variável aqui. Na verdade resolve, porque é uma promessa. Então
revisando aqui, create, pega, atualize o ID, último ID incrementado, faz um objeto para
nova companhia, copia as propriedades, dados pelo, para aquele que chamou essa função, seta
o ID, agora atualiza a lista de companhias com o concreto, com a nova companhia, finalmente
dá o resolve com nova companhia. Salva isso. Por isso é só para a companhia, para criar
uma companhia. A próxima etapa agora é criar um produto, então vamos fazer isso na próxima
aula.


000f-21 Atualizando nosso Banco de Dados Simulado com Métodos para Criar Recursos (Companhia)

Atualizando nosso Banco de Dados Simulado com Métodos para Criar Recursos (Produto)

```markdown
# Resumo da Transcrição

O autor discute a implementação de funcionalidades para uma API que manipula produtos e companhias. Aqui estão os principais pontos abordados:

1. **Correções e Ajustes**:
   - O autor começou com uma correção, mencionando que esqueceu de adicionar uma vírgula.
   - A operação da aplicação agora está rodando sem erros.

2. **Estrutura da API**:
   - A parte do código discutida é a `api-index.js`.
   - O arquivo já contém funcionalidades para encontrar produtos (`find produtos`).

3. **Implementação do Método `create produto`**:
   - O autor fala sobre implementar o método para criar um novo produto.
   - O novo produto é definido como um objeto e uma nova promessa é retornada (usando `resolve` e `reject`).
   - É utilizada uma simulação de tempo com `setTimeout` para mimetizar uma espera.

4. **Gerenciamento de IDs**:
   - O autor menciona a necessidade de gerenciar IDs, definindo uma variável para o último ID disponível.
   - O último ID é incrementado para gerar um novo ID para o produto que está sendo criado.

5. **Validação e Propriedades do Produto**:
   - É mencionado que o foco não é na validação dos dados do produto, pois se presume que eles já estão validados ao serem passados pelo usuário.
   - Ao criar um novo produto, as propriedades do objeto são copiadas, e o novo ID é adicionado.

6. **Atualização da Lista de Produtos**:
   - O novo produto é adicionado à lista existente de produtos usando `concat`.
   - Finalmente, a promessa é resolvida com o novo produto, que inclui o ID, para que o cliente receba a confirmação.

7. **Conclusão**:
   - O autor finaliza mencionando que os métodos de simulação para criar um produto e uma companhia foram implementados.

```


Continuando aqui, eu esqueci da vírgula, depois do 3 pontos companhia, pareceu aqui,
vou salvar, está rodando sem erro agora, tinha esquecido da vírgula aqui.
Vamos lá proceder para api-index.js, é onde tem o banco de dados fácil para os produtos
e tem aqui já find produtos para encontrar todos os produtos, todos os produtos pela ideia da companhia
e um produto específico, vamos adicionar agora da mesma, da mesma jeito, vamos falar create
produto e faço o produto como objeto, I return new promise, promessa, resolve reject, set time out,
para simular uma espera, presentes, eu esqueci set time out aqui, olha, o presentes lá, define
produto por id, esqueci de passar o tempo, vamos verificar os outros presentes, presentes está certo.
Então voltando aqui a create produto, faz aquela mesma coisa, temos que definir o último id,
então produtos aqui, vamos criar uma variável, o último id, que vai ser nesse caso, vamos dar uma olhada,
tem um, dois, id três, id quatro, id cinco, vai ser o último id, tá, vai aqui, primeiro fala que o último id
é o último id mais um, para incrementar, mas é isso, pode usar isso aqui também, se você quiser
depois disso a gente tem que fazer o quê, vamos ver, criar novo produto, copia as propriedades do produto,
vou adicionar o id, que agora é o último id, vamos supor que tudo já está validado quando o usuário
passa esse cara, a gente não quer se preocupar com isso, que a gente está focando mais de um gráfico que ele
e tem esse simulado aqui, depois disso a gente vai pegar set a produto, set a lista de produto,
agora é uma nova lista, com o concat, passa aqui o novo produto e adicionando o final da lista,
finalmente dá o resolve da promessa para o novo produto para o cliente poder saber,
receber aquele objeto do produto incluindo o id, tá bom?
e com isso a gente termina de fazer, implementar os methods do simulado para criar um produto e para criar uma companhia,
então até a próxima!


000f-22 Atualizando nosso Banco de Dados Simulado com Métodos para Criar Recursos (Produto)

Como Criar uma Mutation no GraphQL (Aula Tutorial Curso)

# Resumo da Aula sobre Mutações em GraphQL

Nesta aula, aprendemos a criar mutações no GraphQL, que são operações usadas para criar, atualizar ou deletar recursos. Diferente das queries, que são utilizadas para obter dados, as mutações permitem a modificação dos dados.

## Estrutura do Código

1. **Arquivo `index.js`:** Utiliza o middleware do GraphQL, `express-graphql`.

2. **Arquivo `schema.js`:**
   - Definimos um novo esquema GraphQL que contém:
     - Uma propriedade `query` para operações de leitura.
     - Uma nova propriedade `mutation` para operações de escrita ou modificação.
   - Criamos um novo `GraphQLObjectType` chamado `mutation`, adicionando campos que representam as operações que queremos realizar, como "adicionar companhia".

## Adicionando uma Mutação

- Para adicionar uma nova companhia, criamos uma mutação chamada `adicionar companhia`.
- Esta mutação recebe como argumentos:
  - `nome` (string)
  - `fundada em` (string)
  - `site` (string)
  
  Todos os campos são requeridos.

- A função `resolve` para a mutação invoca um método `create` no arquivo de companhia (companaya.js), que retorna uma nova companhia.

## Executando a Mutação

1. **Formato da Mutação:**
   ```graphql
   mutation {
     adicionarCompanhia(nome: "Oracle", fundadaEm: "data", site: "oracle.com") {
       id
       nome
       fundadaEm
       site
     }
   }
   ```

2. **Resultado:**
   - A mutação retorna um objeto que representa a nova companhia, incluindo um ID gerado e os dados fornecidos.

## Verificação da Mutação

- Após a execução da mutação, executamos uma query para obter todas as companhias e confirmamos que a nova companhia "Oracle" foi adicionada com sucesso.

## Revisão do Que Aprendemos

- Criamos uma nova propriedade `mutation` no esquema GraphQL.
- Adicionamos o campo `adicionar companhia` e definimos os tipos e requisitos dos argumentos.
- Implementamos o método `resolve` que interage com o backend para criar uma nova companhia.
- Confirmamos a funcionalidade através da execução de uma query para verificar a adição da nova companhia.

**Conclusão:** A aula forneceu um passo a passo sobre a implementação de mutações em GraphQL, usando um exemplo prático de adição de uma nova companhia ao sistema.

Nesta aula nós vamos aprender a criar mutações.
Mutation, como é chamada no inglês, é uma operação especial do GraphQL que a gente
usa para poder criar recursos, atualizar recursos ou deletar recursos.
Você já aprendeu a query.
A query é usada para obter dados, seja de um recurso individual ou de vários recursos,
múltiplos recursos.
Então nesta aula vamos aprender a criar um recurso usando a mutation.
Então vamos lá.
Então estou aqui no arquivo index.js, usando o middleware do GraphQL, express GraphQL.
Vamos dar uma olhada no esquema, vamos lá para o arquivo schema.js.
Lá no final, cadê?
Módulo.exports aqui, a gente define um novo GraphQL esquema.
Esse esquema tem a propriedade query, que é um objeto type.
A gente vai criar outra propriedade aqui chamada mutation.
Depois de query vamos definir mutation.
Note que tem muita coisa aqui, então recomendo depois como re-fatorização você extrair
essas partes em um arquivo separado.
Então vamos continuar.
A gente vai fazer a mesma coisa, quase a mesma coisa que a gente fez para query, só
muda a propriedade, agora se chama mutation.
New GraphQL ObjectType, passo um object.
Não precisa de motivi-la.
E da mesma maneira que a gente fez anteriormente, nós vamos ter propriedade name para o nome
da object e os fields, os campos.
Vamos lá.
Nem vamos mudar mutation type, fields.
Agora a gente tem que adicionar as fields para as operações que a gente quer fazer.
Por exemplo, se eu quiser criar uma companhia, adicionar uma companhia, então a gente pode
adicionar essa operação aqui.
E você chama o nome da operação, adicionar companhia.
Aí você diz o tipo.
Nesse caso vai ser o tipo de object que você espera ser retornado dessa chamada aqui,
dessa mutation.
Normalmente quando você cria uma nova companhia, você recebe de volta o object da companhia
com o ID, então você pode usar companhia type.
Se você olha aqui, é bem parecido com as anteriormente que temos companhia para pegar
todos os companhias, companhia para pegar uma única companhia.
Então a gente vai ter, depois do type, você tem que dizer quando você cria companhia,
você precisa saber do cliente os dados da companhia.
Então para isso você vai usar args para receber argumentos com os dados da companhia.
Eu vou começar de maneira simples, eu vou por cada argumento aqui da companhia e depois
a gente ver como melhorar isso.
Então para a companhia, se você lembrar, se eu explico, olha aqui, companhia tem um nome
fundado em inside, então vamos adicionar isso.
Nome, nome vai ser type o quê?
Nome é tipo, vamos fazer de outra coisa aqui.
Vai ser graph que é o string, mas vamos deixar assim depois a gente ver se é um campo
requerido ou não.
Então nome tem um nome fundado em, também é um string, graph que é o string e tem
também o site, mesma coisa, tudo é string, graph que é o string.
Você pode determinar se esses campos aqui são requeridos ou não.
Vamos dizer que todos os campos são requeridos, então você tem que dizer aquela mesma técnica
que a gente fez anteriormente, se lembra do no no para dizer que você não pode ser
no esse campo.
Então vai usar isso para cada um desses caras.
Então vou dizer no, não, opa, graph que é o no no e passa o tipo como argumento.
Então isso significa que, vou ter essa viva aqui, que esse, por exemplo, esse próprio
propriedade nome não pode ser não.
Então definindo os argumentos para receber, para criar a nova campanha, não precisa de
id que id é criado pelo backhand.
Com isso a gente faz depois de args.
Tem a resolve, resolve que vai dizer como fazer operação para o graphical.
Então vamos lá.
Depois de args, você vai escrever resolve.
Primeiro argumento para value, segundo args.
Agora para poder criar um novo recorde, se lembra que lá no companhia .js a gente criou
aquele methodo create.
Então se você falar cria, companhia.create e passar o objeto com os dados da companhia,
ele vai criar a nova campanha e retornar no resolve.
Dá promessa.
Então vamos fazer isso.
Vamos lá.
Você fala companhia e já está querido lá em cima, ponto create.
Agora você tem que passar o objeto da companhia.
Onde é que está esse cara?
A companhia tem um nome, a companhia tem um dado em, a companhia tem que mais.
Onde estão esses caras?
Você se lembra que a gente definiu args?
Esses são os argumentos que você pode passar quando você fizer essa query pelo companhia
para adicionar companhia.
Então você pode passar o nome, fundar em e o site.
Então esses caras aqui vão aparecer dentro do objeto args na metade resolve.
Então você pode falar args?nome, args?fundada em e assim por diante.
Args.site.
Tá bom?
Então esse vai passar o objeto, aí você retorna do resolve.
E com isso ele vai criar companhia e retornar no objeto resolve.
E ver se isso vai funcionar.
Vamos lá.
Voltando ao navegador, localhost 3000 barra.
Vamos fazer o seguinte, vê dizem query, você agora vai dizer mutation.
Aí você abre aqui as chaves.
Agora diz o nome do campo, né?
Nesse caso aqui o campo da mutation que a gente adicionou é adicionar companhia.
Agora adicionar companhia, abre as chaves, mas você tem argumentos.
Então você adiciona os parentes aqui e adiciona cada argumento.
Primeiro vai ser o quê?
O nome da companhia.
Por exemplo, o nome...
Vamos usar companhia aqui.
Vamos usar Oracle.
Aí adapta de fundação.
Eu nem sei.
Então vou botar qualquer data aqui, tá certo?
Tá errado.
Então...
E o site.
Oracle.com.
A gente tem que usar aspas duplas, tá?
Isso que quer dizer isso, cara.
Em vez de só uma...
Vamos usar aspas aqui.
Tá bom.
Então tá aqui, ó.
Esse que é o nome da field que a gente adicionou a mutation, se lembra?
E aqui são os args, argumentos, nome, fundada em e o site.
Então dentro dos chaves você vai passar aos campos que você quer que seja retornado
do back end.
Então tem que ser pelo menos um, por exemplo, só o ID.
Ou se você quiser receber tudo, só adicionar mais nome, fundada em site.
Tá?
Então vamos fazer isso.
Play.
Você note aqui que ele retorna dessa mutation, a mutação.
Um objeto com o ID 4.
Se lembra que a gente tinha três campanhas, uma com o ID 1, 2 e 3.
Agora tem o ID 4, que é o novo recorde com Oracle.
Data de fundação que tá provavelmente errado.
E o site.
Pra você ver que isso realmente funcionou, olha aqui.
Vou comentar essa, na verdade eu vou adicionar a query aqui e vou dar query pra todos os
companhias.
E eu quero o ID, nome, fundada em e site.
Você pode criar um fragmento aqui pra poder reutilizar esses caras, tá?
Se lembra?
Então deixa eu ver aqui.
Vamos dar o nome a query pra poder identificar no play, obter companhias, companhias e
mutação.
Também posso dar o nome, a mutação.
Vou dar o mesmo nome, adicionar companhia.
Então eu posso escolher qual pra rodar.
Vou rodar a mutação ou rodar a query.
Quer a query agora?
Pra ver se realmente criou.
Então você note que a query de obter companhias.
Agora tem um novo objeto que é a oracle, tá?
Então essa é a mutação.
Vamos revisar o que a gente fez.
Então a gente já tinha aqui no nosso companhia, outro JTS, aquela função create pra criar
companhia no nosso backend simulado, no ORM.
Vamos fechar isso.
Aí o que a gente fez aqui?
Dentro do schema.js a gente criou um novo GraphQL que já tinha a propriedade query,
que é um novo GraphQL object type.
Aí o que você faz?
Adiciona nova propriedade e suba o nome pra mutation.
Aí vai ser bem similar ao que a gente já tinha feito pra query.
Então você diz o nome desse cara, só diz mutation type e as fields que são os campos.
E eu adicionei o campo chamar adicionar companhia que a gente usou aqui.
Olha aqui no lado esquerdo, primeira código.
Então o type aqui é o tipo de objeto que vai ser retornado depois de executar essa
mutação, nesse caso o companhia type.
Você passa os orgs pra poder passar os argumentos pra criar uma nova companhia.
A gente passou aqui, olha aqui, nome fundado em insight nos parênteses ali, depois o nome
do field, do campo que adiciona a companhia.
Aí tem o resolve que você pode pegar e chama a companhia create com um objeto da nova
companhia e cada argumento, cada propriedade vem do orgs.
Tá bom?
E se lembra que a gente passou o new graph, no, no pra dizer que cada argumento é obrigatório,
ou se não pode ometer.
Tá bom?
Então por essa aula é só e até a próxima.


000f-23 Como Criar uma Mutation no GraphQL (Aula Tutorial Curso)

Como Usar Input Type para Facilitar a Mutation no GraphQL (Aula Tutorial)

# Resumo da Aula sobre Input Types em Mutations

Nesta aula, aprendemos a utilizar **Input Types** para simplificar a definição de mutações no GraphQL, especificamente para adicionar uma nova companhia. Aqui está um resumo dos principais pontos abordados:

## O que são Input Types?

- Os Input Types permitem agrupar vários argumentos em um único objeto, facilitando a passagem de dados para a mutação.
- Em vez de receber múltiplos argumentos separados (como nome, data de fundação e site), podemos encapsular todos eles em um único argumento.

## Criação do Input Type

1. **Definição de um novo tipo**:
   - Criamos um tipo chamado `companhiaInputType` como um `GraphQL input object type`, que contém os mesmos campos que o tipo de companhia, mas sem o ID.
   - Os campos definidos são: `nome`, `fundada_em`, e `site`.

2. **Configuração dos campos**:
   - Os campos no input type podem ser definidos como obrigatórios utilizando `new GraphQLNonNull(GraphQLString)`.

```javascript
const companhiaInputType = new GraphQLInputObjectType({
  name: 'companhiaInput',
  fields: {
    nome: { type: GraphQLNonNull(GraphQLString) },
    fundada_em: { type: GraphQLNonNull(GraphQLString) },
    site: { type: GraphQLNonNull(GraphQLString) },
  },
});
```

## Modificação da Mutações

- Alteramos a mutação para que o argumento não seja uma lista separada de `args`, mas sim um único argumento, `input`, que é do tipo `companhiaInputType`.

```javascript
addCompanhia: {
  type: companhiaType,
  args: {
    input: { type: companhiaInputType },
  },
  resolve(parent, args) {
    const { nome, fundada_em, site } = args.input;
    // lógica para adicionar a companhia
  },
}
```

## Conclusão

A introdução de Input Types torna a manipulação de múltiplos argumentos mais eficiente e organizada. A mutação agora espera um único objeto, permitindo uma estrutura clara e simplificada durante a adição de novas companhias.

Estamos de volta, acabamos de aprender na uma télioca como fazer uma mutação,
a Muteche, para poder adicionar uma nova companhia.
Nesta aula nós vamos falar de input type para poder facilitar a criação de recursos
aqui na nossa Muteche.
Nos argumentos, em vez de ter vários argumentos separados, vamos ter só um argumento que
embrulha todos os outros.
Então, vamos falar de input type.
Note aqui que quando a gente criou a mutação para adicionar a companhia, temos aqui os
argumentos com o nome da companhia, a data de fundação e o site.
E todos eles são separados.
E você nota aqui de volta de todo o texto, lá no Muteche de adicionar a companhia,
nós criamos args e separamos cada arg aqui.
E quando você dá o Creator todos são separados.
Agora, seria legal se a gente pudesse pegar todos esses argumentos e colocar em uma só
propriedade, uma só entidade.
Para isso a gente vai usar input types.
Para input types vai ser assim.
Você note aqui de volta o esquema 4js, lá no definição do companhia type, nós definimos
esse tipo aqui com o nome companhia e as fields, os campos de D, nome, fundada e site e um
relacionamento aqui com os produtos.
Então, para poder fazer o seguinte aqui, em vez de dizer esses caras separados, você
pode fazer input e passa um objeto de ssamsim, o chave, ao redor de todas as propriedades,
para poder fazer isso a gente vai usar input type.
Input type você faz o seguinte, você vai criar um novo tipo chamado companhia input
type.
Agora, não vai ser GraphQL object type, vai ser GraphQL input object type.
Então, vai ter as mesmas fields de companhia, exceto o ID, porque a gente só precisa do
nome, fundada em e o site.
Então, vamos aqui em cima, antes de companhia type, vamos definir companhia input type,
vai ser new GraphQL input object type e passa um objeto.
Agora, a gente não tem esse cara requerido, vamos lá em cima e requerir GraphQL input
object type.
Adicionei a lista de requerir methods ao pacote GraphQL.
E com isso, vamos continuar aqui.
Então, a gente vai fazer aquela mesma coisa, name, com o nome da field, companhia input,
eu vou chamar.
Qual é os fields, os campos?
Os campos vai ser o nome, fundada em e site.
Então, eu posso até copiar do companhia type, tá?
Copiar aqui.
Nome, fundada em e o site.
Agora, se você quiser deixar cada um desses argumentos obrigatórios, você pode adicionar
new GraphQL, no, no e chamar-se cara com todos a string, tá?
Então, vou descerar esse e esse.
Dessa maneira, todos os argumentos serão obrigatórios.
Então, criamos o companhia input type, que é um GraphQL input object type.
Depois de a gente criar isso, a gente tem que modificar a nossa mutação.
Vai lá embaixo na mutação, newTest aqui.
Em vez de falar os orgs aqui, dessa maneira, você vai, eu vou comentar aqui só para deixar
o código para você, você vai falar input, o argumento vai ser input, aí você põe
companhia input type, tá?
Aqui, ó.
Dessa maneira.
Aí quando chegar em orgs, não vai ser mais orgs, nome, fundada em site.
Você pode pegar o input que está dentro do orgs, tá?
Isso significa orgs.input, eu pego esse cara e põe na variável input.
Então, aqui, em vez desses caras de orgs, você pode votar input.
Tá?
Em salvar.
Vamos agora tentar novamente, voltando ao navegador.
Vamos ver, você adiciona a propriedade aqui.
Input e passa um objeto, se informar a trugação.
Vou executar adicionar a companhia.
Adicionar a companhia, deixa eu reiniciar.
O tipo de mutation type para adicionar companhia tem que ser input type, mas ele é o bitve
undefined, então vamos ver o que está acontecendo aqui.
Eu botei companhia input type como input.
Retorna companhia type, tá certo.
Companhia input type lá em cima.
Graphic é o input object type.
Companhia input, fields.


000f-24 Como Usar Input Type para Facilitar a Mutation no GraphQL (Aula Tutorial)

Como Usar Produto Input Type para Facilitar a Mutation no GraphQL

# Resumo do Transcript

Neste vídeo, o autor discute como implementar mutações e tipos de entrada (input types) usando GraphQL para gerenciar informações sobre companhias e produtos.

## Principais Pontos:

1. **Mutação para Adicionar Companhia**:
   - É mencionado que deve-se adicionar um input type para a companhia, garantindo que a propriedade `type` esteja correta.
   - O uso de `graphql` para tornar o campo obrigatório é explicado.

2. **Input Object Type**:
   - É sugerido criar um `input object type` para a companhia que inclua campos obrigatórios, como nome e data de fundação.

3. **Uso de Variáveis**:
   - O autor menciona que o aprendizado sobre variáveis em GraphQL será útil para futuras implementações de consultas e mutações.

4. **Mutações para Produtos**:
   - O usuário é incentivado a criar uma mutação para adicionar produtos, similar ao que foi feito para companhias.
   - A estrutura da mutação é delineada:
     - Nome da mutação: `adicionar produto`.
     - Campos do input type: ID do produto, nome, data de lançamento e imagem.

5. **Criação do Produto**:
   - O autor fornece detalhes sobre o método `create produto`, enfatizando a necessidade de passar os parâmetros corretos.
   - A conexão com a API é feita, e a estrutura dos campos é revisada.

6. **Obtenção de Produtos**:
   - O uso de consultas (`query`) para obter os produtos criados é demonstrado.

7. **Integração com Companhia**:
   - O autor destaca que a companhia deve ser vinculada ao produto criado através do ID da companhia.
   - Ao adicionar um produto, é mostrado como passar o ID da companhia.

8. **Teste e Validação**:
   - O processo de adicionar um novo produto e verificar se a companhia correspondente também aparece na lista é apresentado.

## Conclusão
O vídeo aborda as etapas necessárias para implementar mutações e tipos de entrada em GraphQL, demonstrando como gerenciar entidades como companhias e produtos, e como vincular ambas usando IDs. A interação com a API é um aspecto central do processo.

Então vamos, volto aqui, a mutação, adicionar a companhia, a companhia type, args, cada arg
tem um objeto type, então olha aqui, input, eu esqueci de botar dentro de um objeto com
o propriedade type, então objeto, propriedade type, como eu fiz anteriormente aqui.
Posso aproveitar também e fazer esse campo ser obrigatório, então vou usar new, graphql,
no no para o campo companhia ser o input ser obrigatório, se não tem nada para adicionar.
Então vamos tentar novamente, de volta ao navegador, vou ter companhias, tenho as três,
adicionar, agora adicionou o novo companhia, tá?
Então, receluzando o input type, por convenção você põe a propriedade de nome input, faça
aqui esse cara aqui e você cria um input type para a companhia, só para pegar os dados
mais fundamentais, nome, fundado em USITE, tem que ser criado como um input object type,
esse detalhe, aí você põe os fields lá repetidos, você pode até acompanhar input e de
volta aqui na mutação, você põe lá no args, põe um input, convenção e type,
companhia input type, new, graphql, no no para poder fazer o seu campo obrigatório,
tem que ter o companhia para poder criar, tá?
Então, esse negócio vai ser bem útil quando você aprender sobre variáveis,
que você pode até, olha aqui ó, query verbos, você pode adicionar variáveis para
as suas query ou mutação e vai aparecer aqui depois do nome, na mutação,
ou da query, então a gente ainda não sabe isso, mas vai poder usar isso depois, tá bom?
Então, vamos aqui, vou voltar o dito de texto, eu quero ver você fazer a mesma coisa para
criar um produto, tá bom? Faça uma mutação aqui, primeiro para criar, adicionar produto, faça um
input object, produto input object type e faça a mesma coisa que a gente fez aqui,
é certo para o produto, então vou esperar você fazer aí, depois a gente continua juntos,
e aí vamos lá, vamos aqui, vamos adicionar,
então nós temos, adicionar produto, mutação, nome vai ser, opa, não precisa de nome,
type, quando você adiciona produto, você pega de volta o quê?
Produto type, agora o args, vamos usar o input, que vai ser type, produto, input type,
a gente vai criar já já, depois disso resolve, value args, nós vamos fazer o quê?
Vamos chamar, nesse caso da API, se lembra API barra index, JTS, temos esse método create
produto, é só para assar o produto como objeto, volto a esquema, API create produto,
passa o produto, nesse caso vai ser o args, input, eu não vou filtrar nenhum parâmetro,
é isso como você quiser fazer, e vou retornar esse gar aqui, agora vamos fazer produto
input type, lá em cima, antes de produto, vamos aqui com esse produto, input type, new
graph, o quê? input object type, passa o objeto, basicamente nome, quase mesmo coisa
produto input, e os fields vai ser o quê? Vamos pegar o produto ID, nome, lançado em
imagem, então vamos pegar só copiar nome, lançado em imagem, vamos fazer calda, campo
obrigatório, new graph, o quê? Não, não, tá, é só isso, depois a gente lidar com os
produtos, vamos põe no seu quê, tá, então vamos lá, sonar produto, não sei o quê, vamos
testar, mutation, adicionar produto, nome da mutação, só para ter o nome, adicionar
field, dentro dessa metade, argumento inputs, vamos passar o quê? Tem o nome, vamos põe,
ipod, lançado em, nem lembro, sei lá, tá qualquer data aqui, tá errado provavelmente,
imagem, imagem eu não vou pôr qualquer coisa aqui, aí você tem que sempre dizer em a,
o quê que você quer ser, que seja retornado, só quero o ID, então recebi o ID 6, vamos fazer
uma query aqui, query, obter produtos, só o nome, eu vou falar produtos, e eu quero
ID, nome, lançado em imagem, vou rodar obter produtos, e tá lá embaixo o ipod que a gente
acabou de criar, tá bom, note que não tem companhia ID para esse cara que a gente não
adicionou, então não tem companhia, você vai adicionar companhia e o nome, não vai ter,
então vamos margainar isso, de volta aqui, a nosso input, produto input, você vai adicionar o
companhia ID, se você quiser que seja obrigatório, no GraphQL int, tá, adicionar companhia ID,
agora vamos criar o produto de novo, e vou passar companhia ID para C, acho que 1 né, que
é o Apple, vamos ver adicionar o produto, opa, não foi provided, hum, eu acabei adicionando
aqui não, ah, companhia ID, desculpa, ID, pronto, criou 6, vamos lá rodar o obter produtos,
e apareceu aqui, e a ipod lançado em companhia ID 1 e o companhia apareceu, agora aparece a Apple, tá,
então isso corrige aquele problema, a companhia, tá bom, não por essa aula é só, e até a próxima.


000f-25 Como Usar Produto Input Type para Facilitar a Mutation no GraphQL

Validação de Campo no Resolve da Mutation do GraphQL (Aula Tutorial)

```markdown
# Resumo da Aula sobre Validação de Entradas

Na aula de hoje, discutimos como realizar validações de entradas, especialmente na mutação para adicionar uma nova companhia. O exemplo abordado foi a validação de um site que deve começar com "HTTP" para garantir que não seja um link quebrado.

## Validação de Site

1. **Objetivo**: Validar se a string do site começa com "HTTP".
2. **Método**: Utilizar uma expressão regular.
   - Estrutura: `/^HTTP/`
   - O símbolo `^` indica o começo da string.
3. **Teste no Navegador**:
   - Usamos `HTTP.test(input.site)` para verificar a validação.
   - Se a string não começa com "HTTP", o resultado será `false`.

## Implementação da Validação

1. No resolve da mutação `adicionarCompanhia`, implementamos a validação.
2. Caso a validação falhe, um novo erro é gerado:
   ```javascript
   throw new Error("O site deve começar com HTTP");
   ```
3. Ao testar no GraphQL:
   - Se um site inválido (ex: "HTTPX") for adicionado, um erro será retornado.

## Conclusão

Adicionamos validações diretamente nas mutações, permitindo verificar condições como a formatação de um site ou a validade de uma data. Essa prática é essencial para garantir a integridade dos dados fornecidos.

## Exercício

- Praticar adicionando validações adicionais, como a confirmação de que a data está correta.

A aula termina aqui. Até a próxima!
```

Fala pessoal, nesta aula vamos falar um pouco aqui de como você pode fazer validação
de entradas, por exemplo, se você tiver companhia e você, por exemplo, alguém digitar o site,
para uma string para o site que não tem HTTP no começo da string, então seria um link
quebrado talvez, então você pode fazer essa validação aqui, se você for lá no esquema
da s, lá quando você for criar uma companhia, aqui no companhia, cadê? na mutação, tem
a mutação mute-txt aqui para adicionar a companhia, essa mute-txt tem um resolve que
vai resolver, vai fazer a criação da companhia, aí do resolve da mutação adicionar a companhia,
você pode adicionar uma validação aqui, por exemplo, se você quiser checar se o site
contém uma string e começa com HTTP, pode fazer o seguinte, você vai aqui e põe o
state para checar, se o site começa com HTTP, para poder fazer isso você pode usar uma
expressão regular, põe as duas barras, põe o circunflexo para dizer que é o começo da string,
seguido de HTTP, então você pode usar ponto test e passa a string que você quer testar,
nesse caso vai ser input.site, então esse cara aqui se você fizer, ele vai pegar, dar uma
olhada nessa string e se começar com HTTP ele vai retornar true, vamos olhar no navegador para
ver como isso funciona, estou aqui no navegador, deixo abrir o console, então se eu tiver por
exemplo o site é HTTPX, está errado né, e eu vou que quiser testar esse cara, eu posso dizer duas
barras com o mês da string, HTTP ponto test e a variável, a string né, então você note que ele
retorna falso porque não começa com HTTP, mas se tivesse começado HTTP você testa agora
o true, está certo? Então vamos fazer isso, voltando ao editor de texto aqui no nosso resolve
para a mutação adicionar a companhia, você vai fazer, para você poder dizer que houve um erro de
realização, é só você dar o true, new error, você cria um novo erro, uma mensagem né, a site tem
que começar com HTTP por exemplo, vamos ver no que dá, onde ele faz isso, vamos lá no navegador
pro graphical, eu vou fazer uma mutation, adicionar companhia, o input vai ser, vamos só
adicionar o site que HTTPX, porque está errado, deixa só assim, eu quero que retorne o ID
e o site, então eu falei porque já tem validação padrão para campo obrigatório, que a gente usou
não, então vamos adicionar o nome, companhia nova e fundada em, eu botar qualquer coisa aqui, note que
tem validação para data, você poderia também adicionar isso, tentar novamente, então adicionar
companhia, site no seu que, e parece que criou, vamos ver aqui, cadê o erro, query, eu quero pegar as
companhias, o ID, nome, site, dá o nome aqui para poder dar o play, se não tiver nome não vai dar certo,
então adicionar companhia para a mutation, nome dela, e obter companhias para essa query,
vou rodar o Bt com companhias, olha que adicionou mesmo, será que eu só vi, vamos ver aqui, parece que não deu certo,
eu vou dar o console logo para ver se entrou aqui, ah, eu acho que já sei, ter que negar esse cara, né,
vou ter que negar isso tudo, porque quando você teste o RetroNTrue, se for realmente começar com a HTTP,
mas eu quero só que executa esse cara, se realmente não começar, né, então ter que negar,
então era o negar aqui, vamos de novo lá, eu vou clicar adicionar companhia, então deu o erro já,
eu acho que eu termina o console logo, então agora está certo, deixa eu remover o console logo,
então só adicionar o sinal ali para negar, então voltando aqui para o cenote, query manda o erro,
diz o mensagem, site tem que começar com HTTP, que é o argumento que a gente passou por construir o erro,
tá, e ela diz o perf, adicionar companhia, que é o nome da notação, e dada você recebe no,
vamos obter companhias, você vê que não adicionou lá, tenta novamente adicionar, não deu certo,
obter companhias, nenhuma nova companhia adicionada, tá, então vamos avisar o que a gente fez,
então você pode adicionar validação de campos na própria mutação, por exemplo a mutação para adicionar
uma companhia, você pode fazer isso na função do método de resolvedor, resolve aqui antes de você criar
a sua companhia você vai checar pelos argumentos, nesse caso eu usei a expressão regular para ver se o
a string do site da companhia começa com HTTP, não esqueça de negar nesse caso para o teste,
para ver se tem um erro, aí o que você faz é você joga, throw um novo erro, tá, e diz o mensagem para
descrever o erro, você pode fazer isso até para testar aqui se a data estiver informado correto e outras
coisas, tá certo, você pode fazer isso como um exercício, tá, então por essa aula é só e até o próximo.


000f-26 Validação de Campo no Resolve da Mutation do GraphQL (Aula Tutorial)

Como Criar uma Mutation para Remover um Recorde (Aula Tutorial de GraphQL)

# Resumo da Aula sobre Mutação para Deletar Companhia

Na aula, foi abordado como implementar uma mutação para remover uma companhia em um sistema simulado de gerenciamento. A seguir estão os principais pontos discutidos:

## Implementação do Método `destroy`

1. **Objetivo**: Adicionar um método que permita a remoção de uma companhia pela sua ID.
2. **Arquivo**: O código foi editado no arquivo `rm-compania.js`.
3. **Novo Método**: Foi criado o método `destroy`, que aceita o `id` da companhia como argumento.
4. **Uso de Promessas**: O método utiliza uma `Promise` com um `setTimeout` de 300 milissegundos:
   - Verifica se a companhia existe utilizando o método `filter`.
   - Assegura que apenas a companhia correspondente ao ID fornecido seja removida da lista.
5. **Retorno**: O método geralmente não retorna valor (pode retornar um objeto vazio). Se a companhia não for encontrada, retorna a lista sem alterações.

## Atualização do Esquema GraphQL

6. **Adição da Mutação**: A mutação foi adicionada ao esquema GraphQL:
   - Um novo campo `removerCompanhia` foi criado.
   - Especificação do tipo de retorno como `companhiatype`.
   - O ID da companhia a ser removida foi definido como um argumento obrigatório.

## Testes da Mutação

7. **Teste no Navegador**: 
   - Um exemplo de chamada para a mutação foi criado.
   - Se o ID não for fornecido, uma mensagem de erro será retornada.
   - A mutação foi testada com sucesso, recebendo a confirmação da remoção da companhia.
   - O retorno de um objeto vazio após a remoção foi abordado, explicando que deve sempre haver um campo para retornar, mesmo que não exista um valor.

## Conclusão

A aula conclui com a implementação final bem-sucedida de uma mutação para remover companhias, destacando a importância de testar as funcionalidades e a estrutura do GraphQL. 

> **Nota**: Assegure-se sempre de fornecer os argumentos necessários em chamadas de mutação, e lembre-se de que a remoção não retorna dados específicos, a não ser por um objeto vazio, indicando que a operação foi realizada com sucesso.

Temos de volta, vamos na esta aula fazer a mutação para poder deletar, remover uma
companhia.
Vamos atualizar o rm simulado aqui, o rm-compania.js.
Vamos ver que já temos o findAll, o find, o create, agora vamos fazer o método aqui
para simular a destruição, a delação do recorde.
Vamos chamar isso de destroy, e o que a gente precisa só para remover uma companhia é
o id da companhia, tá certo?
Então vou fazer a companhia id com um argumento para esse cara.
De novo a gente está dentro do arquivo rm-compania.js.
Aqui a gente criou um novo método chamado destroy que leva como argumento o id da companhia,
que eu chamo companhia id.
Então vamos fazer aquela mesma coisa.
Return new promise, resolve reject, set time out, 300 milissegundos.
Então vamos lá.
Primeiro a gente tem que ver se realmente a companhia existe.
Então você pode até checar com o find se ela existe ou não, e se não existir você
pode retornar no algo.
Eu vou só...
Vamos ver aqui.
Ou a gente...
Vamos até fazer o seguinte, vamos só usar o filter, aquele método que você pode aplicar
uma lista para filtrar a certa companhia, excluir, criar uma lista e excluir aquela
companhia, cujo id corresponde ao id fornecido, tá?
Então vamos fazer só isso mesmo.
Então vou falar companhias, companhias.filter, companhia.
Então a gente vai fazer o seguinte, a gente vai deixar passar todos os objetos, acerto
aquela companhia cujo id é o id fornecido, tá?
Então você vai...
E você deixa passar qualquer companhia cujo id não corresponde ao id fornecido.
Então a gente vai terminar com a lista, excluindo aquela companhia se existir, né?
Se não existir não vai encontrar e retornar a mesma lista, tá?
Normalmente do destroy não se retorna nada com o valor.
Então eu posso resolver, sei lá, com objeto em branco vazio, tá?
Você poderia também a comedição de checar se a companhia realmente existiu ou não,
e se ela existe, você poderia...
Se ela não existe, você poderia jogar um reject pra simular um 4 ou 4 não encontrado.
Eu deixo você ir com o exercício pra você se quiser fazer, tá?
Então vamos lá aqui, salva esse.
Temos agora o método destroy do companhia.
Então vamos lá ver.
Voltando aqui no nosso esquema, vamos lá pra mutação, se lembra?
O meu texto que tá dentro do novo gráfico é o esquema.
E vamos adicionar a nova mutação aqui pra poder remover a companhia, tá?
Então agora do fields do meu text type você vai adicionar remover companhia.
Então vamos lá.
Remover companhia.
Sou um novígula.
Então remover companhia realmente não retorna nada, mas vamos só escrever companhia type
aqui com o valor de retorno.
Agora os orgs vai ser o quê?
O id da companhia pra ser removido.
Id type, GraphQL index, tá?
São argumentos fornecidos pelo cliente.
Pra gente ter que dizer o resolve pra dizer como vai remover esse cara.
Então pra remover você precisa do orgs, que é o segundo argumento daqui.
Value orgs.org.id.
E acho que é só isso, vamos ver.
A gente vai chamar companhia.destroy com o id da companhia que é giveind.org.id.
E você vai retornar isso.
Isso cara, retorno promessa que resolve com um objeto vazio.
Tá?
Então vamos lá.
Ah, esqueci também que você deve fazer o id ser obrigatório.
Então new, GraphQL.
Não, não.
Pra ele já jogar o erro, se você não fornecer o id, tá?
Por isso vamos testar essa mutação no navegador.
Vou deixar aquela mesma.
Vou criar a nova mutação aqui, mutext.
Remover companhia, dá o nome pra essa mutação pra poder escolher lá no botão de play.
Remover companhia de novo, porque esse aqui é o nome do campo que aparece lá na nossa definição da mutext.
E você tem que passar argumentos, né?
Aqui ó, o argumento vai ser o id, a companhia pra ser removido.
Vamos ver 2.
Note que eu não passo a id, o que acontece aqui?
Vamos ver.
Remover companhia.
Deward syntax.
Deixa eu remover os parênteses.
Remover companhia, ai não deu eu.
Deixa eu voltar a id aqui.
Pronto.
Field.
O campo remover companhia.
Argumento id é obrigatório, né?
Mas não for fornecido, então tem que fornecer.
Por isso que a gente adicionou o GraphQL.
Não, não.
Agora vamos aqui remover companhia 2.
Valdade de novo.
Então...
Ele fez isso com sucesso porque a gente recebeu alguma coisa, não recebeu não eu.
Você pode olhar seu rodalbe e ter companhias, que realmente remover companhia número 2.
Então o que acontece se eu remover id aqui?
Vamos ver.
Remover companhia.
Então ele dá esse erro, então você tem que pelo menos ter alguma coisa pra...
Espera que você espera ser retornado.
Embora que não tenha realmente um id...
Quando você remove, né?
Não tem id porque a nossa função destroy retorna o objeto vazio.
Então tem esse lance aqui de sempre ter que ter algo pra pelo menos um campo pra retornar ainda que o campo não exista, certo?
Então é meio esquisito, mas é assim que é.
Então você passa o id da companhia pra remover e põe aqui pelo menos o id.
Embora que você realmente não vai receber nenhum id, então só recebe não.
Mas isso realmente significa que deu tudo certo, tá?
Então é isso, uma mutação pra remover a companhia.
Pra essa aula é só e até a próxima.


000f-27 Como Criar uma Mutation para Remover um Recorde (Aula Tutorial de GraphQL)

Como Usar Variables no GraphQL (Variáveis - Aula Tutorial)

# Aula sobre Variáveis no GraphQL

Nesta aula, exploramos como utilizar variáveis no GraphQL através de uma query para obter uma companhia e uma mutação para adicionar uma companhia.

## Passos Abordados

1. **Criando Variáveis em uma Query**:
   - Ao definir uma query, adicionamos parênteses após o nome da query.
   - Declaramos as variáveis usando o símbolo `$` seguido do nome da variável e seu tipo (por exemplo, `ID!` para um ID requerido).
   - Exemplo:
     ```graphql
     query obterCompanhia($id: ID!) {
       companhia(id: $id) {
         nome
       }
     }
     ```

2. **Definindo Variáveis no GraphQL Console**:
   - No cliente GraphQL (graphiql), usamos a aba de **Query Variables** para passar as variáveis em formato JSON:
     ```json
     {
       "id": 4
     }
     ```
   - Na query, substituímos o valor direto pelo nome da variável `$id`.

3. **Observando o Pedido HTTP**:
   - Após executar a query, podemos observar o pedido no console, onde ele mostra os campos `query` e `variables`.

4. **Usando Variáveis em Mutação**:
   - Para uma mutação, o processo é semelhante. Após definir o nome da mutação, também usamos parênteses para as variáveis:
     ```graphql
     mutation adicionarCompanhia($input: CompanhiaInput!) {
       adicionarCompanhia(input: $input) {
         id
       }
     }
     ```
   - Portanto, passamos o `input` definido em **Query Variables**:
     ```json
     {
       "input": {
         "nome": "Nova Companhia"
       }
     }
     ```

5. **Revisão dos Passos**:
   - Para usar variáveis:
     - Adicione parênteses após o nome da operação.
     - Declare as variáveis com `$`, tipo e, se necessário, sinal de exclamação para campos obrigatórios.
     - Utilize o nome da variável onde for substituí-la.

## Conclusão

Com isso, aprendemos como as variáveis podem ajudar a tornar nossas queries e mutações dinâmicas em GraphQL, permitindo uma maior flexibilidade no envio de dados. Até a próxima aula!

Olá pessoal, nesta aula nós vamos falar de variáveis no GraphQL.
Então, eu tenho aqui uma query para obter companhia, tá?
E tenho uma mutação para adicionar uma companhia.
Eu já rodei a mutação e criei essa nova companhia aqui.
Se eu rodar o obter companhia, olha aqui, a gente recebe companhia.
A note que eu sempre estou mudando a ideia aqui, né?
Mas normalmente, do cliente, você não vai escrever diretamente o ID aqui.
Você vai passar variáveis de vários locais do seu aplicativo.
Então, a maneira para você passar variável para essa query aqui, é assim, olha.
Onde você tem query e o nome da query, você adiciona os parênteses aqui, tá?
Aí você faz o seguinte.
Você vai dizer assim, olha.
O dólar, o nome da variável e você tem que dizer o tipo da variável.
Depois dos dois pontos.
Neste caso, o ID é um int, né?
Int. E esse int vai ser requerido.
Então, para obrigatório, você adiciona o sinal de exclamação, tá?
Porque não pode obter companhia sem o ID, né?
Então, é obrigatório esse campo.
Aí você vai ter essa variável, tá?
Aí você vai no query variables aqui embaixo do graphical para simular a criação das variáveis, tá?
Vou abrir um objeto e vou dizer que o ID, em formato JSON, tá certo?
Vai ser, por exemplo, 4.
Aí, dentro desse cara aqui do campo companhia, em vez de falar 4, você tem que dizer a variável aqui.
Mas a variável se chama dólar e ID, tá?
Então, a variável, o valor será substituído aqui.
Qualquer valor que você passe como query variables aqui.
Então, vamos testar.
Obter companhia, tá?
Então, funcionou direitinho.
Vamos olhar aqui no console para ver o que aconteceu.
Vou olhar na aba de Network, de rede.
E vou rodar de novo.
Obter companhia.
Deixa eu olhar lá.
Eu vou dar uma olhada no pedido HTTP aqui, que foi post.
Mas olha só o que é que ele passou como o pedido.
Ele passa query, né?
A propriedade query com aquela query que a gente escreveu.
E ele passa também variables, variáveis, né?
Nesse caso, tem um ID quad, tá?
Esse valor será substituído aqui,
onde ele encontrar esse dólar e ID dentro aqui do campo, do argumento, né?
Olha aqui, ó.
Então, é isso, como se usa variáveis.
Você pode fazer a mesma coisa para adicionar a companhia.
Nesse caso, a variável seria para o input, né?
Então, vamos aqui, ó.
Você vai do lado do computation ter o nome da mutação.
Aí, do lado do nome, adiciona as parênteses e fala o nome da variável.
Dólar, nesse caso, input, tá?
Aí, dois pontos.
Agora, tem que indicar o tipo dessa variável.
O tipo será, qual é aquele tipo?
Companhia input, né?
Vamos ver se esse cara parece que eu cliquei lá.
Você não acha que tem aqui companhia input.
Eu quero que esse campo seja obrigatório,
então eu vou adicionar o sinal de exclamação depois do tipo, tá?
E com isso, em vez de pegar esse objeto aqui, ó,
eu vou recortar e vou falar o nome da variável que é input.
Aí, aqui no query variables, eu vou adicionar o input.
Eu vou colar e vou mudar para JSON, adicionar as aspas para a propriedade.
Nome da propriedade.
Aspals for site, tá?
Formato JSON aqui.
E vamos rodar aqui, ver se dá certo.
Vou rodar, adicionar a companhia.
E adicionar com ID5, tá?
Se você olhar no Chrome, o pedido aqui lá embaixo,
tem o nome da operationalame,
que é o nome da operação, adicionar a companhia, né?
Tá? Essa é o nome da mutation.
Tem a query, né?
Que é aquela coisa que a gente escreveu.
Ah, essa query é, na verdade,
parece que botou as duas juntas, mas...
Eu só queria saber da mutation, ó.
Mas tem a variables, tá?
Tem agora input aqui, que a gente já adicionou, tá?
Então, voltando aqui,
vamos revisar.
Para poder usar variáveis, você abre parênteses
depois do nome da mutação ou do nome da query,
imeditamente depois da palavra chave.
Aí você define os parâmetros das variáveis,
o nome da variável com dólar, sinal de dólar,
seguir dois pontos e o tipo da variável.
Se você quiser que o campo seja obrigatório,
adicione o sinal de exclamação.
Aí, qualquer lugar que você queira usar,
substituir o valor dessa variável,
você põe o nome da variável, dólar, input,
aqui dentro dos argumentos do campo.
Aí você usa, no caso do graphical, que é um cliente,
você pode usar essa aba aqui de query variables
para definir as variáveis,
tem que putar em formato JSON com propriedades
como o nome da variável, tá?
Então, por essa aula é só e até a próxima.


000f-28 Como Usar Variables no GraphQL (Variáveis - Aula Tutorial)

Pedido de HTTP para Fazer o Seu Próprio Cliente de GraphQL

# Resumo da Aula sobre Clientes de GraphQL

Nesta aula, discutimos como criar um cliente de GraphQL a partir do zero, usando requisições HTTP. Apesar de já existirem várias bibliotecas disponíveis, como Apollo e Relay, o foco aqui é entender o funcionamento básico das requisições para um servidor GraphQL.

## Ferramentas

- **Postman**: Utilizado como cliente HTTP para demonstrar as requisições. Você pode baixá-lo em [getpostman.com](https://www.getpostman.com).

## Estrutura do Pedido

1. **Endpoint**: As requisições são feitas para `/graphql` usando o verbo HTTP POST.
2. **Estrutura JSON do Pedido**:
   - `operationName`: Nome da operação que você deseja executar (ex: obter companhia).
   - `query`: A query GraphQL que você deseja executar, que pode incluir consultas (`query`) e mutações (`mutation`).
   - `variables`: Um objeto JSON para as variáveis utilizadas na query.

## Exemplo de Requisição

- Para obter informações de uma companhia:
  ```json
  {
    "operationName": "obterCompanhia",
    "query": "query obterCompanhia($id: ID!) { companhia(id: $id) { nome, site } }",
    "variables": {
      "id": "3"
    }
  }
  ```

### Mutação

- Para adicionar uma companhia:
  ```json
  {
    "operationName": "adicionarCompanhia",
    "query": "mutation adicionarCompanhia($nome: String!) { adicionarCompanhia(nome: $nome) { id } }",
    "variables": {
      "nome": "Nova Companhia"
    }
  }
  ```

## Considerações Finais

- Use `\n` (barra invertida + n) para quebras de linha na query JSON.
- Normalmente, as queries são armazenadas em arquivos separados e importadas conforme necessário em aplicações front-end, como React.
- Há clientes de GraphQL prontos, como Apollo Client e Relay, se você preferir não desenvolver seu próprio cliente.

Esta aula forneceu uma introdução ao envio de requisições GraphQL e à construção de um cliente simplificado. Até a próxima aula!

Nesta aula vamos falar um pouco de como você pode fazer o seu próprio cliente de GraphQL.
Antes de a gente começar a aula, gostaria de dizer que já há vários clientes de GraphQL.
Por exemplo, existe o Apollo e existe o Relay.
Se o sol me mostra, Apollo, GraphQL.
Tem esse cara aqui, o Apollo.
E acho que serve tanto como um servidor como o cliente.
Tem o Apollo cliente.
Tem também Relay.
Relay, GraphQL.
Esse aqui.
Tá.
Só uns clientes que já existem.
Nesta aula a gente só vai falar de como você pode fazer seus próprios pedidos de HTTP para o servidor de GraphQL.
Para poder a gente dar uma olhada nisso, vou usar o Postman.
Postman é o meu cliente aqui para fazer pedidos de HTTP.
Se você quiser baixar o Postman, pode ir em Postman.
Postman, getpostman.com, tá certo?
Para baixar esse aplicativo se você quiser.
Então, vamos fazer esse pedido aqui para obter a companhia.
Eu quero olhar no console, no DevTools, na Abbot Network.
Eu quero ver qual é o pedido, como é que ele é feito.
Note que o pedido é feito ao barra GraphQL, o verbo post, tá?
E na payload aqui, ele tem esse objeto, em formato JSON.
Tem essa propriedade operation name, que vai ser o nome nesse caso da operação.
Vai ser, no caso, vai ser o nome da query.
Tem a propriedade query, que é a nossa query lá que a gente escreveu, do GraphQL.
Observe que tem query e tem mutação no lado direito, no lado esquerdo, query.
No lado direito, primeira linha, tem mil textos.
Então, você tem que dizer a ele qual operação você quer executar, nesse caso, usando o operation name.
Obter companhia, que vai ser a query, obter companhia, tá?
E tem a variável que a gente usou dentro da propriedade variables, tá?
Formato JSON.
Vamos dar uma olhada no...
Adicionar companhia agora?
Vou clicar em adicionar companhia.
Operação com sucesso.
Vou lá para a aba network, rede.
E vou dar uma olhada aqui.
Mesma coisa, barra, GraphQL, verbo post.
Operation name agora é adicionar companhia.
Na hora de que a query é a mesma.
É certo que agora o operation name mudou para adicionar companhia, que é o nome da butação.
É o nome, logo após a palavra, chave, mutation, tá?
Então, isso é preciso para indicar qual operação ser realizada.
Tem a variables aqui como antes.
Então, a gente vai fazer a mesma coisa aqui, esse pedido lá do postman, para ilustrar como você pode fazer.
Sobre o próprio cliente.
Estou aqui no postman, vou botar a variable post, barra, GraphQL.
Vou clicar em body, que é corpo.
E vou botar raw e application direction, tá?
Então, vou digitar a direction.
Primeiro a gente tem que dizer operation name, né?
Vamos testar obter companhias.
Tem que ser duas aspas.
E a query, né?
A query você tem que escrever.
Normalmente, você salva essas queries já escritas em um arquivo e você pode importá-las e substituir...
E só usar variables depois para substituir os valores, tá?
Como a gente já escreveu a query lá no GraphQL, vou copiar de lá.
Então, deixa eu minimizar.
Vou copiar essa query aqui, olha.
Que está aqui.
Tá.
Deixa eu copiar só a query.
De volta postman.
Collei, eu não sei se vai funcionar assim porque os...
Tem quebra de linha, tá?
Está vírroa aqui.
Agora, para variables, você vai passar nesse caso, só o ID.
Vamos por 3.
Vamos ver no que dá.
Enviar.
Então, está dizendo que deu erro, postbody.
O JSON está aí válido, provavelmente por causa da quebra de linha.
Ah, vamos ver aqui como fazer isso.
Vamos ver para quebra de linha, você tem a...
A barra invertida seguida de n, eu vou botar isso e ver se funciona.
Barra invertida, seguida de n.
Barra invertida, seguida de n.
Claro que você iria programar isso para fazer isso automaticamente, né?
Só quero ilustrar.
Vamos funcionar o negócio.
Vamos ver agora.
Então query, obte companhia, eu usei o barra invertida n.
Para indicar a quebra de linha.
Agora, falou que não conhece a operação, obte companhias, porque...
Ah, é singular, porque eu escrevi o nome da query que é obte companhia.
Enviar.
Então, deu certo.
Microsoft, um dado em...
E o site.
Tá?
Então, do seu cliente, você vai enviar fazer um pedido,
HTTP, verbo post, barra, grafo, PL.
Aí, você vai passar as seguintes propriedades no formato JSAM.
O nome da operação, nesse caso, é JSAM.
O nome da operação, nesse caso, é o nome da query.
Se fosse mutação, você...
Era só o nome da mutação.
Aí, na query, você vai pôr, seja query, seja mutação, qualquer coisa.
E para a cara quebra de linha, uso barra invertida n.
E para variáveis, você diz variables, faça um objeto aqui, tá?
Esse valor será substituído na query aqui, por exemplo,
com esse dólar, pelo próprio servidor.
Tá?
Então, é isso.
Nessa aula, a gente aprendeu como fazer um pedido para poder...
fazer nosso próprio cliente de GraphQL para fazer o pedido ao servidor,
é só usar o operation name query and variables, tá?
Normalmente, você escreveria as queries, daria o nome a cada query,
para poder usar o operation name.
E você escreveria esse no arquivo separado e você importar...
importa query lá do seu cliente,
você tem, por exemplo, um aplicativo de React
ou qualquer outro...
de front-end, você vai...
aí, importa query, pega aquela query, põe nessa propriedade aqui,
faz um pedido do h2tp, sei lá, fetch,
ou axios, qualquer coisa, e põe as variables, põe operation name, essas coisas, tá?
Portanto, notar que já existem clientes de GraphQL como Apollo Client
e o Relay, se você não quiser fazer tudo do zero.
Por essa aula é só. Até a próxima.


000f-29 Pedido de HTTP para Fazer o Seu Próprio Cliente de GraphQL

Revisão e Conclusão do Curso de GraphQL com servidor Express

# Resumo da Aula de GraphQL com Express

Nesta aula, foi concluído o curso sobre GraphQL com Express. A seguir, um resumo dos principais tópicos abordados:

## Instalação e Configuração
- Instalamos pacotes como **Express** para rodar o servidor e **Express GraphQL** como middleware.
- Usamos `app.use` para definir o endpoint de GraphQL e configuramos o middleware com o schema.

## Schema de GraphQL
- **Query**: Usado para obter dados.
- **Mutation**: Usado para criar, atualizar ou deletar dados.
- A declaração do schema é feita com `new GraphQLSchema`.

## Tipos do GraphQL
- **GraphQL Object Type**: Define os tipos de objetos, como `rootQueryType`.
- Cada tipo tem **fields**, que são os campos desse tipo, como obter todas as companhias ou uma companhia por ID.
- O método **resolve** determina como encontrar os recursos solicitados.

## Definição de Tipos
- **Companhia Type**: Utilizamos `GraphQLObjectType` para definir campos como ID, nome, data de fundação e site.
- Realizamos relações entre companhias e produtos através de fields.
- Usamos **GraphQL Non-Null** para indicar que um campo é obrigatório.

## Mutações
- Definidas de maneira similar às queries, com um objeto GraphQL e ao menos um field por operação (ex: adicionar ou remover companhia).
- Os argumentos do usuário são coletados através da propriedade `args`.
- Implementamos **Input Types** para simplificar a passagem de múltiplos argumentos como um único objeto.

## Erros e Resolução
- Aprendemos a criar erros personalizados para retorná-los ao cliente caso ocorra algum problema, como por exemplo, se o site de uma companhia não começar com "http".

## Testando com GraphiQL
- Testamos as queries e mutações utilizando a ferramenta GraphiQL, acessível pelo navegador.
- Podíamos utilizar variáveis em nossas operações, definindo tipos e requisitos conforme necessário.

## Conclusão
- Ao final, o curso forneceu uma compreensão abrangente sobre como implementar e testar APIs GraphQL utilizando o Express. 
- Agradecimentos aos participantes e incentivo para continuar praticando.

Obrigado por participar e até a próxima!

Olá pessoal, nesta aula nós concluímos o nosso curso de GraphQL com Express.
Então vamos dar uma revisada.
Então a gente começou tudo instalando os placotes Express para poder rodar o nosso servidor
e Express GraphQL, que é o middleware de Express.
Nós usamos o middleware com app.use para o endpoint.graphql e chamamos o middleware que passamos o schema.
Também usamos o graphical só para debugar e testar o nosso servidor de GraphQL aqui.
Dentro do esquema de GraphQL nós determinamos duas propriedades.
Nós definimos o query, que são usados para obter dados.
Definimos a propriedade mutation, que é uma mutação,
normalmente usada para quando você cria, atualiza ou deleta dados.
Quando você cria o seu esquema de GraphQL você tem que dizer new GraphQL schema.
Nesses tipos você pode requerir do pacote chamado GraphQL.
Quando a gente faz nossa query a gente diz novo GraphQL object type, que é tipo objeto.
Esse tipo objeto sempre tem o nome, que é nem propriedade nem...
Você diz qualquer nome, nesse caso eu diz root query type, que é a query haiz.
O ponto de partida do nosso aplicativo para cada query vem daqui.
E tem as fields, são os campos desse tipo.
Nesse caso eu tenho um campo para cada recurso, por exemplo, para obter todas as companhias,
para obter uma só companhia por ID, para obter todos os produtos e assim por diante.
Por exemplo, para companhias pressa field, a gente sempre tem o type.
Nesse caso é uma lista de companhia type, a gente definiu o nosso propriedade para companhia.
E tem o método resolve, que é usado para dizer ao GraphQL como encontrar esse recurso.
É a função ou o método resolver.
Para a companhia type nós definimos nosso próprio tipo aqui usando o GraphQL object type,
sempre aquela mesma coisa, name, que é o nome do tipo, e o fields.
Metodo de fields, cada campo tem o tipo, nesse caso um ID, GraphQL int, que é inteiro.
Tem o nome da companhia, que é uma string, data de fundação, que é uma string também,
embora que seja uma data, tem o site também que é uma string.
E tem também o relacionamento a produtos por meio do campo chamado produtos,
que é uma lista de produto type, que é outro tipo que a gente criou.
Nós temos o método resolve do para poder localizar os produtos dessa companhia.
Se você tiver uma companhia tal, você pode pegar o ID da companhia, que é o chamado parent value, o valor pi.
Nesse caso será a companhia e eu posso pegar o ID da companhia dizendo parent value.id.
Nós definimos nossa API simulada com o método para poder encontrar produtos por p, o ID da companhia.
Se você olhar também o produto type, ver aquela mesma coisa, name, e fields.
Nós definimos o fields com uma função que retorna o objeto por causa daquele problema do companhia type aqui,
ser indefinido quando você executar o código.
Se você mudar o objeto para uma função que retorna o objeto para o fields,
não vai ter mais problema de companhia não ser definido, companhia type.
Também fizemos um ORM simulado para poder acessar um banco de dados falsos e encontrar companhia.
Nesse caso é o relacionamento do produto que pertence à companhia.
A gente adicionou a field chamada companhia e na função método resolve do,
ele usa o parent value.compania.id.
Nesse caso o parent vai ser o produto e você usa o campo companhia.id para poder encontrar companhia desse produto.
Estou voltando aqui às nossas campos para query.
Companhias, companhia, aprendemos o GraphQL non-null para poder indicar que o campo é obrigatório.
GraphQL non-null não pode ser valor-null.
E assim por diante.
Então aprendemos também sobre mutações, mutation, faz aquela mesma coisa,
define um objeto GraphQL, name, qualquer nome, mutation.
E os fields, nesse caso cada field será uma operação, por exemplo, adicionar companhia,
remover companhia, adicionar produto assim por diante.
Para fazer uma mutação é quase a mesma coisa que escrever uma query, aquela mesma coisa.
Ponho o type que você espera que seja retornado quando você executar essa mutação.
Nesse caso, normalmente você retorna o objeto da companhia,
incluindo o id quando você termina a operação com sucesso.
Para você obter argumentos ou parâmetros de entrada do usuário, você usa o propriedade args,
que também pode ser usada lá em cima da sua query, não é só para muta.
E você define, nesse caso a gente aprendeu, sobre o input type,
para a gente não ter que digitar, separar cada argumento aqui fornecido pelo usuário.
Em vez disso a gente usou companhia input type, que a gente definiu lá em cima.
Companhia input type é um GraphQL input, input object type.
Tem essa palavra, chave input aqui, e você põe as parâmetros dentro desse tipo, dentro do fields,
com os dados necessários para poder criar uma companhia.
Aí você, quando for no GraphQL, no GraphQL lá, você é só digitar o input aqui.
Formato JSON, em vez de separar cada argumento com um anvírgulo.
É em uma só entidade chamada input.
Voltando aqui ao editor de texto, depois do companhia type, voltando à mutação.
Mutação adicionar companhia.
Tem a função resolver, para adicionar companhia, que a gente aprendeu também como enviar erros ao cliente.
Por exemplo, a gente chegou, se o site da companhia realmente, a string começa com HTTP,
se não começar, a gente faz o seguinte, a gente cria um novo erro,
e dá throw para jogar o erro, e ele vai lá do cliente, dá receber aquele erro,
e não vai continuar para criar a companhia.
Se dá tudo certo, aí você chama companhia create, com objeto da companhia, que vem do args,
que são os argumentos pôrnecidos pelo usuário, pelo cliente, e dentro de args tem input que a gente usou aqui.
Mesma coisa, quase a mesma coisa para remover companhia, adicionar produto, aquela mesma coisa.
Para remover companhia, só precisa do ID da companhia, que é fornecido como argumento ID,
que é tipo GraphQL int, que é obrigatório e não pode ser no.
Tem a função resolver, que chama o ourm-simulado para destruir ou delatar a companhia pelo ID,
fornecido pelo argumento args.id.
Tá bom?
E esse é o code que a gente fez, e a gente aprendeu tudo isso usando,
testou tudo isso usando o nosso cliente GraphQL, que é bem útil para a gente testar as coisas.
Do navegador localhost, a porta, barra GraphQL, e você pode escrever as mutações de queries aqui,
pode dar o play, se você não mear cada mutação e query, você pode escolher qual das operações para rodar.
Esse cara vai aparecer no operation name quando você fizer a query.
Você pode também usar variáveis para suas queries ou mutações, é só adicionar parênteses.
Depois do nome da query ou do nome da mutação aqui, não confunda esse nome com o field, que é a companhia.
Não confunda esse adicionar companhia com essa field chamada adicionar companhia, tá?
Então, o parâmetro variables, você pode definir aqui os argumentos com o dollar e o nome da variável,
seguido do tipo da variável, depois de dois pontos.
Se você quiser que essa variável seja obrigatória, você adiciona o sinal de exclamação.
Aí é só dizer a sua field aqui, nesse caso companhia, os argumentos, nesse caso id, que vem com o valor vêm da variável, dollar e d.
Então, o cliente, você pode fornecer essa valor das variáveis, dentro da propriedade chamada variables,
que vai aparecer no seu pedido, no corpo do seu pedido.
Nesse caso, graphical tem essa sessão aqui de variáveis que você passa um objeto de alteração, que você pode definir cada variável aqui, tá?
E esses valores serão substituídos aqui pelo servidor, onde estiverem as variáveis.
Graphical também é interessante, porque você pode clicar nos seus tipos aqui para aprender mais sobre esses tipos de graphical,
até os seus próprios tipos, por exemplo, a gente criou o companhia input, você note aqui no lado direito que tem o nome,
fundado em site e o tipo de cada parâmetro, cada campo, e o sinal de exclamação significa que esse campo é obrigatório, não pode ser branco, ficar em branco, tá?
Então é bem legal, você pode ver companhia, tipo, companhia aqui, os campos, e pode rodar o companhia e pedir assim por diante.
Então, chegamos ao fim do curso, muito obrigado por assistir e até a próxima.
