Transcrições
1. Anúncio de Apollo Graphql: Você está cansado das APIs
REST tradicionais e quer aprender o que há de melhor
e mais recente? O desenvolvimento de RPA não
precisa mais do que
nosso curso GraphQL. Neste curso, você
aprenderá tudo o que precisa
saber para começar
com as garotas Graff, começando com o básico da
construção de um Graciela
BI com o Express. Mas não paramos por aí. Vamos nos aprofundar no uso um servidor de fronteira com
TypeScript e express, trabalhando com o tipo RM e usando o banco de dados
Postgres com docker. Nosso curso não pretende
ser um gráfico completo de custos, mas ensinará a você
todos os fundamentos. Você aprenderá
sobre Graff girls, tipos de
halo, consultas,
mutações, esquemas
e como mesclar esquemas e resolvedores com uma
fotógrafa. A garota também aprenderá TypeScript e Cover Socket IO e uma
migração de banco de dados com fralda. E até o final do curso, você poderá
criar com confiança sua própria API GraphQL e trabalhar com algumas das ferramentas
mais recentes e poderosas do setor. Então, o que você está
esperando? Então, vá agora para nosso campo de golfe Gail e leve suas
habilidades de desenvolvimento de API para o próximo nível.
2. Introdução ao Graphql: Olá e bem-vindo a esta
primeira aula sobre equipamentos gráficos. Nesta lição,
apresentaremos o Dr. Gale, discutiremos dúvidas e mutações e explicaremos o que é um esquema. Então, o que é GraphQL? Graphql é uma linguagem de consulta e tempo de execução para APIs
desenvolvidas pelo Facebook. Ele permite que os clientes peçam exatamente o que precisam
e nada mais. Faça com que seja uma alternativa poderosa
às APIs de resto tradicionais. Uma das principais características do
Graph Gil é sua linguagem de consulta. A linguagem de consulta
permite que os clientes especifiquem exatamente
quais dados precisam, incluindo estruturas de dados aninhadas e
recuperem tudo em uma única solicitação. Isso torna muito eficiente para os clientes recuperar
dados do servidor. Como eles não precisam fazer várias solicitações para obter
todos os dados de que precisam. Vamos falar um pouco
mais sobre consultas. No golfe. Contudo, uma consulta
solicita dados. Ele especifica o campo que
o cliente deseja recuperar, bem
como quaisquer argumentos
necessários. Aqui está um exemplo de uma consulta
simples no GraphQL. Nessa consulta, estamos solicitando os campos de nome e e-mail para
o usuário com um ID de 123 A resposta do servidor pode ser mais ou menos assim. Agora vamos passar para as mutações. As mutações no GraphQL são usadas para modificar dados
no servidor. Eles permitem que os clientes enviem
dados ao servidor para criar, atualizar ou excluir recursos. Aqui está um exemplo de uma mutação
simples no GraphQL. Nessa mutação, estamos criando
um novo usuário com o nome Jane Doe e enviamos um e-mail para
Jane Doe em example.com. A resposta do servidor pode ser mais ou menos assim. Finalmente, vamos falar sobre
esquemas no GraphQL. O esquema é um contrato entre
o cliente e o servidor. Ele define os tipos de dados que podem ser consultados e modificados, bem
como as relações
entre esses tipos. O esquema geralmente é definido usando a linguagem de
definição de esquema GraphQL, ou SDL, para abreviar. Aqui está um exemplo de
um esquema simples na linguagem de
definição de esquema
GraphQL. Nesse esquema, temos um tipo de consulta com
um campo de usuário que recebe um argumento e
retorna um objeto de usuário. Também não temos o tipo de mutação com o campo create user, que pega um objeto de entrada de criação de usuário e retorna um objeto de usuário. Binário. Temos um tipo de
usuário com campos de ID,
nome e e-mail. É isso. Nesta
introdução ao gráfico de Gail, abordamos o que é Garcia, nossa consulta é e as mutações
funcionam no que é o esquema. Na próxima lição, vamos nos aprofundar na
criação de APIs do GraphQL.
3. trabalhando com consultas de Graphql: Olá e bem-vindo de volta
ao nosso curso GraphQL. Em nosso vídeo anterior, abordamos os
conceitos básicos do GraphQL, incluindo consultas,
mutações e esquemas. Neste vídeo,
construiremos um gráfico simples que a gala
PI expressará. Especificamente,
usaremos o Express para lidar com nossas
solicitações e respostas do GraphQL. E
aproveitaremos o poder da Graff girl para recuperar
dados de uma fonte de dados. Ao final deste vídeo, você terá uma sólida
compreensão de como criar a
API GraphQL com o Express. E você poderá aplicar esses conceitos em
seus próprios projetos. Então, sem mais delongas, vamos começar a
criar nosso gráfico. Gala PI com Express. Eu preparei o
projeto para você acompanhar neste vídeo, você pode baixá-lo
na seção de recursos. Eu incluí um
arquivo index.js no projeto. Esse arquivo contém
o código necessário para
começar a escutar
conexões com o Express. Além disso, você encontrará um
arquivo package.json com três dependências. Express, express, Dutch, Graff, girl e graph. Aqui. Essas são as principais
ferramentas que
usaremos para criar nossa
API GraphQL, eu expressaria. Além disso, o node money também é instalado e configurado
no projeto. Essa ferramenta reinicia automaticamente nosso servidor quando
são feitas alterações no código, que nos economizará
muito tempo e facilitará o
processo de desenvolvimento. Agora, antes de começarmos a
trabalhar no projeto, é importante garantir que todas as
dependências necessárias estejam instaladas. Para instalar essas dependências,
basta navegar até o diretório do projeto em seu terminal e executar
o comando npm install. Isso instalará todos
os pacotes necessários para nosso projeto. Quando a instalação
estiver concluída, podemos continuar
construindo nosso gráfico obter RPI com o Express. Agora, em um projeto gráfico Gil, a primeira coisa que você precisa
fazer é definir o esquema, que é a
base de um gráfico. Obtenha o RPI definindo seus
tipos e campos. Precisamos começar com isso antes qualquer outra coisa para
garantir que nossas APIs sejam claras, autodocumentadas,
flexíveis e extensíveis. Para criar o esquema, precisamos importar a função com
o nome build schema
do pacote GraphQL. Em seguida, crie uma
constante de esquema e use a
função build schema abrindo dois parênteses e passando
uma string de modelo. Aqui, vamos definir nossa primeira consulta adicionando
o tipo de palavra-chave como esse e adicionar a consulta nomeada. Em seguida, abra dois colchetes. E aqui dentro podemos
definir nossas consultas. Então, vou definir
uma consulta simples, olá. Em seguida, precisamos definir o tipo de
retorno dessa consulta. Para fazer isso, adicione dois pontos especifique o tipo de retorno. Agora, nosso caso, a consulta hello retornará uma string, certifique-se de adicionar uma letra maiúscula S. Seus tipos são usados para definir
a estrutura dos dados,
incluindo tipos escalares, como strings, inteiros e booleanos,
e tipos de objetos, que consistem em uma
coleção de campos. Agora, para lidar com as solicitações que chegam
à consulta hello, precisamos definir
um resolvedor raiz. A raiz resolvível
é responsável por buscar os dados
solicitados na consulta ou mutação e devolvê-los
ao cliente na
forma correta definida pelo esquema. Essencialmente, o
resolvedor raiz atua como uma ponte entre a API
e suas fontes de dados, tornando-o um componente crítico
de qualquer gráfica ou PI. Agora, para definir esse resolvedor de
rotas, vamos criar uma constante de
rota como e definir seu
valor para um objeto. E esse objeto, precisamos adicionar todas as nossas consultas com o mesmo
nome escrito no esquema. Então, aqui vou adicionar uma propriedade
hello de representar a consulta hello e definir seu
valor como uma função de seta. A propósito, cada consulta ou
mutação deve ser uma função. Agora, aqui vamos
retornar uma mensagem Hello World. Agora, precisamos definir um
Raphael e um flutuante em nossa API. Podemos fazer isso usando o Express. Portanto, é semelhante à
definição de middlewares. Disse o caminho final
para matar a garota Graff. E para o manipulador de solicitações, usaremos outra função
chamada Dr. Gil HTTP. Podemos importá-lo do pacote express,
que é
o GraphQL. Agora, aqui dentro,
vamos usar a função HTTP
do GraphQL dessa forma. Um objeto como argumento. O assunto
manterá nosso esquema. Você pode configurá-lo assim ou apenas com o esquema de nomes
e JavaScript, saberemos que estamos nos referindo
ao esquema constante. A segunda propriedade é a propriedade do valor
raiz, que manterá
nosso resolvedor raiz. E a última propriedade
é o Graffiti Girl, que é um
cliente GraphQL gráfico e
interativo baseado na web que permite aos usuários interagir
com um RPI do GraphQL
executando consultas e mutações e visualizando os resultados. Quando definida como true na configuração expressa
do
middleware GraphQL, a opção gráfica habilita a interface gráfica para testar e explorar
nossa API GraphQL. Com isso dito, vamos salvar nosso arquivo, abrir o terminal e
executar este documento. Em seguida, vamos abrir o navegador e navegar até o localhost 4.000, como Scarf Girl, onde você encontrará a interface
gráfica. Aqui, podemos escrever nossas
dúvidas e até mesmo verificar a documentação
do nosso PR de gala do governo. Aqui você encontrará nossa consulta e dentro dela a consulta hello, que retorna uma string. Se você clicar nele, verá a definição
da string escalar. Agora, para obter a
consulta hello desse servidor, precisamos definir
a consulta desta forma. E então mencionou
toda a consulta dentro dela. Depois de fazer isso, clique no botão Reproduzir para
enviar a consulta ao servidor. Se tudo estiver
configurado corretamente, você deverá ver
o
resultado recebido das consultas no lado
direito do seu cliente. Ótimo trabalho. Na próxima lição, continuaremos explorando essa escala aprendendo
sobre mutações.
4. Adicionando mutações: Agora vamos adicionar uma
mutação à nossa API. Portanto, a mutação do GraphQL
é uma forma de modificar dados no servidor
usando a API do GraphQL. Ele permite que os clientes enviem a solicitação ao
servidor para criar, atualizar ou excluir dados. As mutações são definidas no esquema
GraphQL e podem ser executadas enviando um grafite na consulta de mutação para o servidor. Então, vamos definir a
mutação acessando
o esquema e adicionando um novo tipo. E eu conheci a mutação
com um M maiúsculo E vamos supor que
queremos que o cliente adicione produtos ao nosso lado
do servidor aqui. Isso é um identificador de mutação adicionado
com o nome add product. Esse manipulador aceitará um nome como argumento
do tipo string, novamente com S maiúsculo e
um preço do tipo int, que se refere a um número inteiro. Portanto, em growth Gil, o tipo int representa um inteiro numérico
seno de 32 bytes. É usado para definir
campos que retornam ou aceitam valores inteiros
no esquema do gráfico G 0. Em seguida, o tipo pode ser usado para impor validação de
tipo em
consultas e mutações do GraphQL, garantindo que somente valores inteiros
válidos sejam fornecidos como argumentos. Podemos definir esse
tipo conforme necessário adicionando um ponto de
exclamação na frente dele. Podemos fazer a mesma coisa com
o argumento do nome. Tudo bem, agora precisamos definir um tipo de retorno para essa mutação. Portanto, a mutação do GraphQL precisa um tipo de retorno para
especificar
a forma dos dados que
serão retornados
do servidor após a execução
da mutação. Então, para fazer isso, ou dois pontos
aqui e adicionar uma matriz, porque queremos retornar uma
matriz de objetos de produto. E para definir o tipo
desse objeto de produto, vamos aqui e adicionar outro tipo e
chamá-lo de produto como. Então. Este produto
conterá um nome do tipo string com o ponto de
exclamação para torná-lo obrigatório. E então pressione Enter para ir para
a próxima linha e
certifique-se de não adicionar uma vírgula aqui, pois isso
não é permitido em esquemas de
drift gill. A segunda propriedade é o
preço do tipo inteiro. Também podemos fazer com que o tipo de devolução seja
exigido para evitar a
obtenção de um valor nulo como resultado. Podemos fazer isso adicionando um ponto de
exclamação na frente do produto
e da própria matriz. Também podemos mudar
a forma como listamos nossos argumentos de mutação
e substituí-los por um argumento e chamá-lo de input e definir seu tipo para ser
adicionado por entrada direta. Esse é um tipo personalizado, não um tipo embutido de GraphQL. Portanto, precisamos
defini-la nós mesmos. Nós nos referimos a ele como tipo de entrada. Portanto, no GraphQL, o tipo de entrada é tipo
especial usado para argumentos
em mutações e consultas, é usado para definir
a forma dos dados que podem ser aceitos
como entrada por campo. O tipo de entrada pode conter tipos
escalares, como
string into ou booleano, bem
como outros tipos de entrada que permitem estruturas
aninhadas complexas. Os tipos de entrada são semelhantes aos tipos
regulares e ao tratamento gráfico, mas não podem ser
usados como tipo de retorno de um campo para definir o tipo de entrada
Adicionar produto. Vá em frente aqui e use a palavra-chave de entrada e
adicione o mesmo nome. E dentro dele
adicionaremos os mesmos argumentos, nome do tipo string
e preço do tipo int. Agora vamos salvar esse arquivo e retornar à interface
gráfica. Aqui podemos adicionar nossa consulta
de mutação. Comece adicionando a
mutação na abertura Dois colchetes são
os colchetes e a mutação de
adição do produto. Em seguida, adicione um
argumento de entrada dentro de um objeto, o nome do
produto que diz SPC. Em seguida, tenha cuidado com a entrada de preço ao inserir
números como uma string, uma coisa para funcionar, pois definimos
o tipo como inteiro,
em vez disso, inserimos os números
diretamente, dessa forma. O objeto de retorno,
queremos obter o nome. E o Bryce. Se você apertar o
botão play, não funcionou. E isso porque não
definimos o produto adicionado que pode ser resolvido
no objeto raiz. Isso é muito rápido.
Adicione uma vírgula aqui e crie o produto do anúncio
e a resolução de nossas pernas. Portanto, esse resolvível
aceitará um argumento de entrada. Mas não diretamente assim, porque o
argumento de entrada existe dentro do argumento
do objeto primário chamado args. Assim, podemos obter acesso ao argumento
de entrada da seguinte forma. Então, esse resolvedor deve
retornar uma matriz de objetos. Então, isso é codificado e adicione uma matriz com um objeto
com duas propriedades. Nome, podemos obter o nome
da entrada desta forma. E o preço a partir do preço do ponto de entrada. Então, vamos salvar e testar novamente. E aí está. Nossa matriz com um objeto de
produto contém o nome e o preço. Podemos pedir ao servidor que retorne
somente objetos com a propriedade name removendo
o campo de preço daqui. Clique em play. E como você pode ver,
temos uma matriz de objetos contendo apenas
a propriedade name. Ótimo, agora que você tem um conhecimento básico
do GraphQL, vamos dar o próximo passo para aprimorar sua
experiência
aprendendo a usar um portal graph gail com Express e TypeScript. Apollo GraphQL é
uma ferramenta poderosa que fornece recursos
como cache, tratamento de
erros e junção de
esquemas, facilitando a criação APIs
escaláveis do GraphQL. Ao combinar uma fotografia Gil onde eles expressam,
e o
TypeScript, você poderá criar APIs GraphQL
altamente sustentáveis e seguras. Então, prepare-se para receber o
prêmio de uma fotografia, Gill, e vamos levar suas
habilidades de grafistas para o próximo nível.
5. Instalando e configurando o tipo de texto: Agora, antes de entrarmos na sintaxe
do TypeScript, primeiro
precisamos instalar o compilador
TypeScript para começar a ter um URL de download oval ou TypeScript
lang.org com barra. E aqui você
encontrará várias
maneiras de incluir o compilador
TypeScript em seu projeto, dependendo das ferramentas
que você pode estar
usando. Neste curso. No entanto, vou
confiar no ambiente NPM, pois é isso que
espero que a maioria dos aplicativos
JavaScript
esteja usando atualmente. Agora, independentemente de onde ou
como você instala o TypeScript, se você ainda não tiver o node, precisará instalá-lo
acessando o js.org e seguindo as instruções
para instalar o FTC mais recente. Agora, se você tiver o npm
instalado em seu sistema, vamos voltar para a página de
download do TypeScript e copiar
esta linha aqui. Em seguida, vamos executá-lo, disse nosso projeto e
dentro do nosso terminal. Portanto, certifique-se de criar
um novo diretório aqui, abra o código VS e execute
npm install TypeScript. Isso economiza dinheiro
se você quiser instalar o TypeScript dentro do seu projeto e somente dentro do seu projeto. Mas isso significa que,
com a mesa salva como opção div aqui, você só poderá
usar o TypeScript
dentro deste projeto. Você pode fazer isso, para mim, quero usar o TypeScript
globalmente dentro do sistema. Então, vou adicionar
a bandeira dash g para global e, em seguida,
executar npm install. E talvez seja necessário usar o sudo para executar esse
comando como administrador. E se você estiver usando o Windows, precisará abrir um
novo console de administração. Agora, eu já tenho o TypeScript e estou armazenado globalmente
dentro do meu sistema. Então, eu não vou
executar esse comando. E para garantir que você tenha instalado o TypeScript
com sucesso em seu sistema, você pode executar o TSE, que é V, e você obterá
a versão do TypeScript. Atualmente, estou na versão 443. E não
importa se você tem uma versão do
TypeScript superior à minha. Porque todos os centros de
TypeScript que usaremos
neste curso serão
aplicáveis a qualquer
versão superior do TypeScript. Agora, para usar
a sintaxe do TypeScript e o projeto de dúvidas, precisamos adicionar algumas configurações
do TypeScript. Podemos fazer isso automaticamente
usando a linha de comando do TSC e depois morrer nela. E como você pode ver aqui, temos um novo arquivo dentro do nosso projeto chamado
ts config dot json. Então, vamos abri-lo. E, como você pode ver, TypeScript oferece
muitas opções aqui. Muitos deles são comentados porque não
vamos usá-los. Agora, a primeira
opção não confirmada aqui é o alvo, que representa a versão do script
sigma. Neste curso, vamos
usar meu script six. E se você rolar um pouco
para baixo, encontrará a
propriedade do módulo definida para comentar. Sim. Isso significa que os módulos e os arquivos dot js
compilam. Usaremos a sintaxe de
camada comum porque quase todos os navegadores têm
suporte para esse módulo. Mas se você quiser que seus arquivos sejam compilados com a sintaxe
JavaScript moderna, você pode tentar usar anos de 2015, assim, ES 2015. Mas, como eu disse, vamos
usar a ideia de vir até nós
neste projeto. Agora, abaixo disso, temos a propriedade
raiz que especifica a localização dos arquivos que usam a sintaxe TypeScript. Então, vamos terminar o comentário e continuar apontando para
a raiz desse projeto. Agora vamos rolar para baixo até
a propriedade out their, que especifica a localização
dos arquivos compilados. Então, vamos incrementá-lo. E queremos que todos os nossos arquivos sejam nossos arquivos compilados,
localizados dentro da pasta dist. Não precisamos criar
essa pasta manualmente dentro do nosso projeto porque o TypeScript
fará isso por nós. Ok, agora isso é tudo
que precisamos para começar. Então, vamos salvar o arquivo de
configuração ts e começar a
usar a sintaxe do TypeScript
no próximo vídeo.
6. Typescript básico: É hora de começar a aprender
sobre a sintaxe do TypeScript. E para isso, precisamos de um novo
arquivo dentro do nosso projeto. Então, vá em frente e crie
um novo arquivo e
nomeie-o como ponto principal para TypeScript. Então, aqui
vamos começar declarando uma variável
, chamando-a FirstName e definindo-a como John. Agora acabamos de escrever o JavaScript
normal. Mas se eu passar o mouse sobre FirstName, descobrirei que FirstName
é do tipo string. Agora, podemos encontrar a mesma
coisa com JavaScript puro, mas vamos tentar definir
essa variável como cinco. Agora, recebemos um erro. Se você passar o mouse sobre esse erro, descobrirá que o TypeScript
está reclamando do tipo ou atribuindo um
valor a essa variável. Diz que o número do tipo
não pode ser atribuído ao tipo string porque cinco aqui é um número e John é uma string. Portanto,
é como se o TypeScript dissesse que se você atribuir essa variável desde o início a uma string, precisará mantê-la assim. É por isso que o TypeScript é
útil, pois evita que pequenos bugs como esse
apareçam em nosso projeto. Agora, queremos que a
variável firstname seja sempre
do tipo string. Mas vamos imaginar que outro
desenvolvedor chegue e tenha alterado o valor da variável
firstname para um número, digamos que seja dez. Agora, o IRS desapareceu da segunda linha ou
da terceira linha aqui. Mas introduzimos
outro dólar aqui. A variável firstname não é
mais do tipo string, mas é do tipo número. Agora, você pode
se perguntar por que o TypeScript não nos alertou de que
cometemos um erro? Bem, é óbvio porque
não mandamos ela fazer isso. Portanto, para fazer
com que o TypeScript aceite
apenas strings
para essa variável, precisamos adicionar dois pontos
e depois uma string. Agora você pode ver que
temos dois erros. Bem, é o mesmo erro, mas em dois lugares diferentes. Tem a mesma
mensagem de antes. O número não pode ser atribuído para
digitar string na mesma mensagem. Podemos encontrá-lo aqui. Para corrigir isso, podemos simplesmente remover a dezena daqui e
substituí-la por uma string. John. Na verdade, podemos
remover
isso porque é essa variável e atribuir essa variável
na terceira linha desta forma. E aqui podemos ver que
o IRS desapareceu. Mas vamos
mantê-lo em uma linha. Então, vou pegar
isso de novo e moverei o primeiro nome daqui
e atribuirei isso a John. Agora, se você quiser declarar
um número em vez de uma string, podemos criar outra
variável, nome e idade, definir o tipo como número
e, em seguida, entrar em qualquer número, escolhendo 22. E agora você sabe
que, se fizer isso, receberá um erro dizendo que o tipo string não
pode ser atribuído ao tipo número. Agora não temos apenas
sequências e números, também
temos objetos. Então, vamos declarar
outra variável principal. Chame-o de LPG para objeto
e, em seguida,
defina-o como um objeto com o primeiro
nome da propriedade definido como gráfico. Agora, na próxima linha, vamos tentar reatribuir a propriedade firstName a um número e ver o que
vai acontecer. Portanto, o objeto FirstName é igual a cinco. Agora, aqui você pode ver que
temos um erro do TypeScript dizendo que o número do tipo não pode ser atribuído
ao tipo string. E isso é esperado
porque declarar propriedades de objetos é semelhante a declarar variáveis normais. E a mesma coisa se
tentarmos atribuir o objeto
à variável firstname, obteremos o mesmo erro. E desta vez, a string
do tipo time não pode ser atribuída a um tipo diferente
do objeto que atribuímos à variável
desde o início. Agora, vamos remover
isso e atribuir o tipo de variável a um objeto. Agora, você pode ver que
não recebemos nenhum erro. Mas quero deixar
claro para os olhos que essa variável arbitrária
é um objeto que contém uma
propriedade firstName do tipo string. Podemos fazer isso removendo
o objeto daqui substituindo-o por
duas chaves. E aqui está a propriedade do primeiro nome
e defina-a para digitar strain. Agora, digamos que eu queira adicionar uma nova propriedade a
esse assunto, por exemplo H. Receberemos um erro dizendo que digite o objeto
com a propriedade firstName, string e age number. Não é atribuível
ao objeto que tem apenas a propriedade firstName
do tipo string. Agora, isso será
muito útil se quisermos que nossos objetos contenham apenas propriedades
muito específicas. E, claro, se quisermos adicionar
a propriedade de idade,
que é um número, podemos vir aqui e depois
adicionar a idade do tipo número, e a seta desaparecerá. Agora, depois de strings,
números e objetos, vamos ver como podemos definir
funções com o TypeScript. Então, vamos declarar uma nova
função e nomeá-la. Crie usuário. Essa função
aceitará dois argumentos. primeiro é o primeiro nome, segundo é a idade. Agora você pode ver aqui
que temos dois erros. Firstname ou o parâmetro firstName implicitamente
tem qualquer tipo. Agora, os argumentos das funções também
são variáveis. E os JavaScripts definem o tipo
desses argumentos por
padrão para o tipo any. Mas o TypeScript
não permite isso, então precisamos adicionar tipos
para esses argumentos. Portanto, para o FirstName, addString e para
a idade é um número. Agora vamos retornar algo
dessa função. Retorne FirstName mais h. Você pode ver que não
recebemos nenhum erro porque até mesmo o TypeScript sabe que
queremos converter a idade em
uma string e depois
concatenar uma string e depois com a variável
firstName. Agora, se você alterar o
sinal de mais por um sinal de menos, você receberá um erro. Como o TypeScript
sabe que realizar uma operação de subtração entre uma string e um número,
isso não é lógico. Então, vamos remover tudo isso e substituí-lo por uma string
literal. E dentro dela
teremos firstName, depois adicionaremos a variável firstname e depois age, a variável idade. Crie outra variável
e chame-a de stl string. E então vamos executar
a função de criação de usuário. Agora você pode ver aqui que
precisamos de dois argumentos. Então esse é o primeiro nome de
John e a idade de 22 anos. Agora, se você passar o mouse sobre
a variável STR, você a encontrará do tipo string. Podemos especificar o
tipo de retorno de uma função, pois
podemos fazer isso para uma variável
usando dois pontos aqui
e, em seguida, adicionar o tipo string. Agora, digamos que eu queira
retornar um objeto a partir disso. Obrigado por isso. Vou mudar
isso com o objeto. E receberemos um erro dizendo que o tipo string não
pode ser atribuído ao objeto de tipo, mas a variável STR
é do tipo objeto. Agora, vamos corrigir esse
erro movendo essa string e
substituindo-a por um objeto. O outro se foi. Mas digamos que eu queira
retornar esse objeto com uma propriedade de idade definida
para o argumento da aids. Se eu quiser usar
o valor
de retorno da função do usuário atual, que é um objeto que deveria conter
uma propriedade de idade. Receberemos um erro dizendo que a idade da
propriedade não
existe no objeto do tipo. Pode corrigir isso removendo isso, adicionando um objeto e a
propriedade A's com o número do tipo. Agora, se você passar o mouse sobre h, verá que ele existe
e tem o tipo número. Vamos adicionar também o
FirstName dentro desse objeto e defini-lo como igual
ao argumento firstname. Aqui temos um erro
porque precisamos adicionar
a propriedade firstName
ao tipo
de retorno dessa função. Então, primeiro nome do tipo string. Tudo bem? Agora, digamos que, se
tivermos uma AIDS maior que 20, rejeitaremos essa ajuda
e retornaremos apenas o primeiro nome. Então, aqui, vamos adicionar uma
declaração if e verificar se a idade é igual ou maior que. 20. Nesse caso, retornaremos somente um objeto com
a propriedade firstName. Agora, o TypeScript
não quer me deixar retornar esse objeto
sem a propriedade age. Isso porque dissemos a ela que essa função retornará um objeto com apenas a propriedade age do tipo number e a
propriedade firstName do tipo string. Podemos corrigir isso tornando a propriedade de idade como não exigida adicionando um ponto de
interrogação aqui. Agora o erro desapareceu. E se você passar o mouse sobre aids, propriedade descobrirá que h é
do tipo número ou indefinido. Agora, você pode fazer
a mesma coisa a
insatisfação do argumento de idade, mas somente se esse argumento for o último na próxima discussão. Agora, se adicionarmos o ponto de
interrogação aqui, receberemos um erro dizendo que o objeto é
possivelmente indefinido. Agora, você pode se perguntar por que estamos chateados aqui, não o número. Bem, isso é porque
em JavaScript, tudo é um
objeto, até mesmo funções. Mas você pode encontrar o tipo
do argumento da idade como
número ou indefinido. Se mudarmos a localização
desse argumento e o colocarmos
desde o início aqui, você receberá outro erro. Dizer que um parâmetro obrigatório não pode seguir um parâmetro
opcional. Portanto, se você adicionar um ponto de
interrogação aqui, a seta desaparecerá
da lista de argumentos, mas você receberá muitos erros
na função e fora da função em que a
executamos. Agora não queremos isso. Queremos mudar
tudo como estava. Então, deixe-me remover isso daqui, colocá-lo lá e remover o ponto
de interrogação do argumento H. Agora, digamos que queremos que
essa função aceite
as ajudas como um número
ou como uma string. Podemos fazer isso adicionando uma barra vertical e
adicionando o tipo de string. É claro que temos que
fazer a mesma coisa com
o tipo
de retorno dessa função. Deixe-me fechar isso para
ter mais espaço e adicionar uma barra aqui com
esse tipo de string. Agora, a idade aqui é do tipo, sequência, número ou indefinida. Podemos fazer a mesma coisa
para uma variável, por exemplo, para o FirstName aqui, vamos adicionar uma
string ou um número. Ou vamos fazer isso para a idade. Então, aqui temos um número. Vamos adicionar uma string. Tudo bem? Agora podemos
atribuir a variável
idade a um número
ou a uma string. Assim.
7. typescript avançado: Agora, voltando à função de usuário
atual, imagine se tivéssemos mais propriedades
dentro desse objeto com tipos mais complexos. Nesse caso, não
será conveniente
ter um objeto grande na
frente dessa função. E para corrigir isso, TypeScript introduziu
algo chamado interfaces. Uma interface também é um objeto, mas você só pode usá-la
como referência a um tipo. É assim que podemos declarar
uma interface usando a palavra-chave interface e depois
o nome da interface. E eu vou escolher o usuário. E como eu disse, vamos criar um objeto, mas sem nenhum
sinal de igual ou coluna. Você pode pensar nisso como uma aula. Agora, vamos pegar tudo isso, a idade e o primeiro nome. Corte a partir daí,
remova o objeto, remova os dois pontos e cole-os aqui dentro
dessa interface. Vamos ajustar um pouco o
código. Você pode ouvir o uso de uma vírgula, mas também pode usar um ponto e vírgula ou simplesmente
remover qualquer coisa de lá. Mas eu quero usar ponto e vírgula porque parece mais
organizado dessa forma. Agora, podemos usar a
interface do usuário como qualquer outro tipo. Aqui, os dois pontos e depois
a interface do usuário. E se você passar o mouse sobre ajudas, verá que
a idade ainda tem o tipo string,
number e undefined. Lembre-se de que as interfaces se referem apenas
a um tipo de objeto. Então, se você remover os colchetes
encaracolados
daqui e deixar
os auxiliares, você encontrará. Você receberá um erro dizendo
que string ou número
não é do tipo usuário atribuível
porque o usuário tem, antes de tudo, duas propriedades
e o usuário é um objeto. E faça as mudanças. E vamos criar outra
função e chamá-la de login. Essa função aceitará
um argumento e terá
o nome login ox. Será do tipo login. E, claro, vamos
definir um login de interface. Então, deixe-me copiar esse nome. Aqui está a interface e
defina a interface de login. Portanto,
para que um usuário faça login, você precisará de um
e-mail do tipo string e também da senha do
tipo string. Na verdade, eu quero ter
controle do tipo de senha ao usar a interface de login dentro da função de login. Para fazer isso, podemos alterar
a face central para ser genérica adicionando dois colchetes
angulares como este. E então você pode pensar
nessa interface agora como uma função que aceitará
um argumento como um tipo. E podemos escolher o
nome do argumento. Vou escolher
PWD como senha e atribuirei
esse tipo para a senha. Agora, aqui, se você passar o
mouse sobre o login, descobrirá que o login de tipo
genérico requer um argumento de tipo. Como eu disse, as funções
têm argumentos. Portanto, para o tipo genérico
é o mesmo conceito. Agora, aqui podemos definir
esse argumento adicionando colchetes angulares
e o tipo
da senha dentro
dele como uma string. Agora, com satisfação,
vamos verificar rapidamente se o
e-mail de login args dot é igual, por exemplo que ele fez e a senha de login args dot é igual, por exemplo, à senha. Nesse caso,
vamos voltar a ser verdadeiros. Portanto, o usuário é autenticado. Agora, aqui, senão,
vamos retornar False. Vou definir o tipo
do valor de retorno
dessa função para body. E esse é um novo
tipo que podemos usar. E não precisa de uma definição porque eles booleanos ou
são verdadeiros. Falso. Agora, voltando
à interface de login, podemos usar outra variável
que se refere apenas a um tipo e contém o tipo de
senha para nós. E como a senha não
é um objeto, podemos usar a palavra-chave
interface. Só podemos usar o
tipo alias e, em seguida, nomear
o tipo como tipo de senha. E então podemos adicionar essas
cadeias de caracteres a esse tipo. Então, aqui está uma corda. Depois, podemos usar
o tipo de senha dentro da interface de login. Se você passar o mouse sobre
ela, verá
que o tipo de senha é uma string. Você pode adicionar aqui
uma sequência de caracteres ou um número. E você pode adicionar
qualquer tipo que quiser. Mas as senhas só podem
ser sequências de caracteres ou números. Também podemos usar o
alias de tipo para adicionar um tipo a uma variável ou a um valor de
retorno de uma função. Então, aqui vou
adicionar o tipo login, resultado é igual a volume e
garantir que esteja em maiúsculas. E aqui para o corpo, e podemos usar letras minúsculas
ou maiúsculas. É a mesma coisa. Vamos mudar isso
para resultados de login. Agora, imagine que
temos uma função assíncrona. Vamos usar a
palavra-chave async para definir isso. Nesse caso, recebemos um erro dizendo que
o tipo de retorno de uma função
ou método assíncrono deve ser a promessa global genérica
com o tipo de argumento T. E então ele diz: Você pretendia escrever
esse tipo genérico? Agora, se você conhece JavaScript, saberá que
uma função assíncrona retornará uma promessa. E é assim que podemos definir um tipo de promessa com o TypeScript. Então, vamos mudar o resultado do
login para ser uma promessa porque
essa função retornará uma promessa. E então o genérico
ou o argumento
desse tipo genérico representa o tipo
de retorno real dessa função, ou em outras palavras, o valor resultante ou o tipo de
resolução desse valor. Então, aqui vamos
resolver um booleano. E você pode ver que
o erro desapareceu. Agora, digamos que, se
autenticarmos o usuário, enviaremos um objeto
em vez de verdadeiro. E esse objeto conterá
uma propriedade de nome de usuário, dita novamente a John, e outro
status de propriedade definido como ativo. Portanto, temos um usuário ativo em
nosso banco de dados. É claro que não
temos banco de dados aqui, mas imagine
que temos um. Agora, é claro,
vamos receber um erro. E para corrigir isso, vamos adicionar uma
interface aqui e nomeá-la, numerá-la e citá-la. Também teremos a
propriedade de nome de usuário do tipo string e a propriedade status
definida como string. E aqui receberemos
uma promessa que
resolverá um
booleano ou um número. Então, cometi um erro aqui. Neste momento, a Terra
desapareceu e podemos devolver
uma força ou um objeto. Agora, sobre a propriedade status, só
podemos retornar três status, o status ativo, o status
inativo e o novo status. Então, aqui você tem que sempre
retornar uma dessas sequências. Mas se eu escrevi ativo assim,
nesse caso, cometi um erro de digitação. Mas o TypeScript
não disse nada. Como o TypeScript não conhece essas strings, só se
preocupa com o tipo de propriedade de status que
está sendo dita toString. E como você pode ver aqui, eu já cometi um erro de digitação. Então, como podemos evitar esse
tipo de erro ou erro? Bem, é muito simples. Temos que declarar um tipo de enumeração. Então, aqui, use as
ideias do NM e, em seguida, nomeie esse tipo de status de membro. E vai ser um objeto, mas não vai
se referir a um objeto. Eu vou te dizer como podemos
usá-lo em apenas um segundo. Agora, aqui podemos definir
esses três tipos
adicionando ativos e inativos. E depois o novo status. Agora temos que substituir
essa string aqui pela enumeração de status dos membros. E para isso, temos que usar números status enum também até 2s para selecionar
o status ativo. Tão ativo. Você pode ver aqui que o VSCode
tem os três tipos aqui como um sucesso, pois isso é muito útil para acelerar o processo de
desenvolvimento. Agora vamos escolher ativo. E se você passar o mouse sobre ele, descobrirá que o
status de membro ativo é igual a zero. Agora, você pode se referir
ao status ativo como uma
string adicionando igual. Então ativo. A mesma coisa para os inativos. Aqui, string, cópia inativa. E para os novos também sabia. Agora, se você passar o mouse sobre ativo, verá que ele está ativo
igual a uma string. Agora, dentro da interface do membro, só
podemos aceitar uma
dessas propriedades. Portanto, agora não teremos
medo de digitar incorretamente
um deles. Agora, vamos salvar esse arquivo abrir o terminal
e tentar compilar. Podemos fazer isso facilmente usando o comando TSC e
simplesmente pressionando Enter. O comando TSC
verificará se
temos algum erro ou algum
tipo de erro de script. E então, se tudo estiver bem, teremos uma pasta dist
contendo o arquivo main.js. Se você abri-lo,
encontrará aqui muitos códigos. Mas todos os tipos anteriores
do arquivo main.js
desapareceram e só
temos JavaScript puro. Você pode ver como o TypeScript
compila o tipo enum. E fiz tudo isso por nós. Crânios, o
ponto principal, ponto é um arquivo. E agora você pode dizer que aprendeu praticamente
tudo sobre o TypeScript. Antes de terminar o vídeo, deixe-me
mostrar rapidamente como você pode usar o método de login. Então, aqui, pegue o que
não é
do jogo e passe o objeto com
o e-mail definido como e-mail, senha e senha. E então, como essa
é uma função assíncrona, vamos usar o
método then para obter o resultado. E depois vamos verificar se o status está ativo ou não. E para fazer isso,
vamos criar uma declaração if e verificar
primeiro se o resultado é uma instância
da classe Boolean. E, a propósito, o booleano com B maiúsculo é vidro. E é um redemoinho para o tipo Boolean com
a letra minúscula b. Portanto, esse tipo aqui se refere
apenas a um verdadeiro ou falso. Mas o booleano com B
maiúsculo se refere a uma classe que contém
o tipo Boolean. Então eu vou fazer isso. Se for uma instância de
Boolean, retorne. Caso contrário, pegue o
resultado desse status. Verifique. Se for esse o caso, esse status é igual
a login ou membro. Status ativo. Se sim, vamos voltar
a ser verdadeiros. Ou talvez o log do console. O usuário está ativo. O usuário está ativo. Agora, se você quiser usar
body e com minúsculas, altere isso e
você pode verificar o tipo de booleano com o
tipo de palavra-chave e, em seguida, resultado é igual para
garantir seu volume. E se você quiser
fazer uma verificação como essa com o ponto de exclamação, você pode remover o tipo
booleano
daqui e substituí-lo por nulo. E em vez de retornar false, retornará null. Isso é melhor. E você pode
ver que null também é um tipo. Agora você encontrará
esse arquivo anexado a este vídeo com outros recursos
do TypeScript. Portanto, certifique-se de baixá-los e aprender mais sobre o
TypeScript por conta própria.
8. Criando o schema do graphql: Estou dentro do VSCode e
aqui tenho dois cincos, o arquivo de configuração ts e o
banco tem o arquivo JSON. Agora, para o arquivo de configuração ts, temos algumas novas opções aqui, como se a biblioteca estivesse
configurada para yes, 2021. E a
resolução do módulo também está definida como nota com os tipos
também definidos como nota. Agora, para a opção estrita de
inicialização da propriedade, certifique-se de que ela esteja definida como false ou você pode simplesmente removê-la
do seu arquivo de configuração ts. Agora, feche isso e, a propósito, adicionarei um arquivo zip a este vídeo para que você possa encontrá-lo
nos recursos e downloads. Agora vamos adicionar
alguns pacotes do MPM. Então, aqui eu tenho o
terminal do VS Code. Você pode abri-lo clicando
aqui no terminal e
clicando em novo terminal. Então, aqui vou
instalar novos pacotes como o express com os
tipos for express. E vamos trabalhar com o servidor
Apollo com express. Então, vou instalar
um polo Server Express. E, claro, precisamos do GraphQL
e dos tipos do GraphQL. Então, aqui em Types
Slash Graph Gear. E para o caso de eu
instalar os tipos para anotar. Agora vamos executar esse comando e instalar todos
esses pacotes. Tudo bem, agora deixe-me limpar este terminal e dentro
do diretório raiz, vamos criar uma nova pasta
de origem. E aqui dentro
teremos um
arquivo main.js e um arquivo txt de pontos do módulo. E, por enquanto,
não vamos tocar nesses dois arquivos porque primeiro precisamos criar o
esquema GraphQL. E para isso,
certifique-se de estar novamente dentro do diretório raiz e criar um novo arquivo e chamá-lo de esquema. Aquele Raphael. Tudo bem, agora aqui está o esquema
GraphQL que
consiste em mutações e consultas. Usamos mutações quando queremos
alterar dados dentro do banco de dados. E usamos consultas quando queremos obter dados do banco de dados. Você pode pensar
neles como postagens em solicitações se estivéssemos
usando uma API RESTful. Com isso dito, vamos
definir nossa primeira mutação. E para fazer isso, temos que usar
a palavra-chave type e
depois escrever mutação. E aqui dentro
teremos a mutação de inscrição. Então, certo, inscreva-se e inscreva-se. Ele aceitará a entrada
do usuário. Então, aqui vamos
escrever a entrada como argumento para esse método. E temos que definir o
tipo dessa entrada para
que, ao usarmos essa
mutação com nossa API, saibamos quais argumentos são necessários e quais não são. E defina esse tipo. Temos que usar a
palavra-chave de entrada aqui, certo? Insira e, em seguida, nomeie esse
tipo de entrada Inscreva-se aqui e certifique-se de ter um S
maiúsculo aqui para nós,
para seu tipo ou se é uma
entrada nítida e não é necessária, mas é algo comum de se
fazer com o GraphQL. Então, aqui,
lado da entrada de inscrição , vamos
definir os argumentos de inscrição. E, a propósito, talvez
você não tenha a sintaxe do GraphQL
colorida assim. Porque se você quiser isso, você precisa instalar uma
extensão para o GraphQL. Então, vá até a
seção de extensão aqui e pesquise a extensão
GraphQL. Eu já o tenho
instalado aqui. Portanto, certifique-se de instalar
a mesma extensão. E então
você pode ter que criar um arquivo de configuração depois de
instalar este pacote. Então, role para baixo aqui e você
terá que criar um arquivo YAML dot GraphQL fc dot,
copiar essas duas linhas e colá-las
dentro do seu projeto. E você pode ver aqui
que esse arquivo de configuração começa a direcionar os arquivos
GraphQL mais antigos dentro de nossa pasta de origem. No nosso caso, ainda
não precisamos disso,
mas, no futuro, teremos
vários arquivos GraphQL. Portanto, talvez seja necessário
copiar essa linha e colá-la dentro
do arquivo de configuração. E eu também farei
isso do meu lado. Só para ter certeza que não vamos
esquecer isso no futuro. Então, volte ao nosso projeto
e, no diretório raiz, crie um novo arquivo e chame-o dot GraphQL LRC do que GMO. E aqui, cole esse
código aqui e feche-o. E então você terá os
mesmos estilos para o GraphQL. E não apenas estilos, mas também preenchimento automático. Sim. É por isso que eu recomendo
que você instale essa
extensão e a use. Sempre que você cria um esquema de
eliminação de gráficos apenas para evitar digitação e depuração desnecessária caso tenha cometido algum erro aqui. Sim. Então, só para ter certeza de que eu tenho o GraphQL dentro do diretório
raiz aqui, vamos continuar com
a entrada de inscrição. Portanto, para criar um novo usuário, precisamos de um e-mail do tipo string. E verifique se você tem
um S maiúsculo aqui. E também verifique se
você não
tem ponto e vírgula ou vem aqui. E agora defina também a
senha do tipo string. E também precisamos de um primeiro nome
do tipo string e o sobrenome
do tipo string. E agora vamos usar esse tipo
aqui para a entrada de inscrição. E, como você pode ver aqui,
é semelhante ao
TypeScript quando
se trata de definir e
usar tipos. Sim. Portanto, talvez você não tenha
dificuldades em entender a sintaxe do
GraphQL, certo? Então, agora vamos definir o tipo de retorno
da mutação de inscrição. Agora, sempre que assinarmos, receberemos de volta o usuário, o documento do usuário
e o token JWT. Então, vamos definir isso. E desta vez temos que
usar a palavra-chave type, porque a palavra-chave de entrada
só é usada quando queremos definir as entradas para
mutações ou consultas. E o tipo é usado para definir principalmente os tipos de retorno das
mutações e as consultas. Agora, defina aqui um tipo e
chame-o de resposta terrestre. E aqui teremos um usuário. E então este
será do tipo usuário. E definiremos
isso em apenas um segundo. E aqui também precisamos do token
JWT do tipo string. Agora, além de tudo
isso,
definirá o usuário digitado. Temos que definir o ID
também para o usuário, porque quando começarmos a
usar o banco de dados, retornaremos o ID. Sim, então temos
que definir que, caso contrário, não obteremos o id
do esquema GraphQL quando
solicitarmos o documento do usuário. Então, a identificação aqui. E como estamos
usando o tipo rep, usaremos fraldas
por aí. Com o Postgres. O id
será do tipo número. Mas no GraphQL, não
podemos usar, não temos um
tipo de número como esse, mas temos um tipo N. Sim. E só para ter certeza de
que receberemos o ID toda vez que
solicitarmos o usuário, adicionaremos um ponto de
exclamação aqui. E com esse símbolo, podemos definir um
campo obrigatório dentro do nosso esquema. Agora, o usuário também tem
tudo isso aqui. Então, deixe-me copiar isso
e colá-los aqui. E é isso. Agora vamos usar o tipo de usuário aqui ou o tipo de
resposta do autor. Então, aqui, desequilibre
e depois economize. Agora, precisamos garantir
que a entrada de inscrição também seja necessária para
evitar entradas indefinidas. E o mesmo acontece com
a resposta da Terra. Sim, e agora temos que
definir nosso esquema. E para fazer isso, vou usar
a palavra-chave schema. Então cite isso. Vamos
definir a mutação. E será do
tipo mutação. Então, quando criamos a
consulta, as consultas, podemos vir aqui e criar uma
consulta como essa e , em seguida,
dar a ela o tipo de consulta. Mas, por enquanto, só temos
mutações e garantimos que pelo
menos você tenha
uma mutação ou consulta aqui ou ambas. Caso contrário, você é o
gateway GraphQL que não resolverá. Agora, vamos salvar isso e criar um resolvedor que lidará com
essa lógica de inscrição.
9. Criar um solucionador de auth: Agora que temos nosso esquema
GraphQL definido, vamos criar um resolvedor. E como definimos uma mutação de inscrição
relacionada à autenticação, criaremos uma pasta
dentro da pasta de origem. E dentro dele, teremos
um arquivo de resolvedores. E aqui vamos definir o objeto que
conterá nossa lógica de mutações
e consultas. Portanto, crie uma nova constante
e nomeie-a como resolvedores. E será um objeto
com uma propriedade de mutação. E dentro disso, vamos
definir o método de inscrição. E, claro, o
método de inscrição é um método assíncrono. Agora, os
resolvedores do GraphQL terão um argumento pai e
um objeto contendo o valor de entrada e também um argumento ou um argumento de contexto
constante. Vamos explicar o argumento do contexto quando
definirmos o principal e o módulo. Mas, por enquanto, sabemos
que
receberemos uma contribuição do nosso resolvedor
de inscrições. E todos os argumentos dentro da entrada de
inscrição serão definidos aqui. Para o argumento principal, teremos
o valor
de retorno do resolvedor principal. E isso é somente quando
temos resolvedores aninhados. Mas em nosso projeto,
não vamos usar isso. Mas eu posso, posso te
mostrar um exemplo. Então imagine se quiséssemos
encontrar uma mutação de inscrição, mas não dessa forma. Vamos criar outro
tipo e nomeá-lo, inscreva-se. E aqui teremos uma
curtida com e-mail. E esse método
retornará o conjunto do usuário. E também teremos, como no Google, nos
inscrever no Google. E este retornará
um token do tipo string. Então, para usar isso, também
podemos adicionar a entrada
ao método de largura aqui e, em seguida, remover
essas doenças parentais. E aqui a mutação de inscrição é que você
será do tipo inscrever-se. E com isso,
definimos resolvedores aninhados dentro
dos resolvedores do autor aqui, temos que definir a mutação de
inscrição assim. E só retornaremos
como um objeto vazio. E então, fora do objeto de
mutação, teremos
um tipo de inscrição. Portanto, crie uma
propriedade de inscrição aqui. E dentro dela, vamos definir
a largura do e-mail
e com os métodos do Google. Sim, então aqui com e-mail e depois
vai ser um método. Claro que é assíncrono. Mas agora podemos pegar o pai. Sim. E no nosso
caso, neste exemplo, o pai
será um objeto vazio, mas é assim que podemos obter o resultado aninhado
de como criar resolvedores
aninhados e usar
o argumento pai. Mas, como eu disse,
não íamos usar isso porque é matar demais. Na minha opinião. Só queremos resolvedores simples. Vamos devolver tudo como antes e remover
o tipo de inscrição. Tudo bem. Agora, dentro dos resolvedores da Terra, você pode ver aqui que temos um erro de script de tipo
dizendo que todos esses argumentos aqui não têm tipos e isso
não é permitido com o
TypeScript, como você sabe. No próximo vídeo,
aprenderemos como
gerar automaticamente tipos de TypeScript a partir
do arquivo schema dot GraphQL.
10. gerar arquivos de tipo a partir de esquema: Agora, para gerar automaticamente
tipos digitados a partir do nosso esquema GraphQL, precisamos instalar
alguns novos pacotes. Então, vá até seu terminal
e execute npm install dash, D
maiúsculo para dependência de desenvolvimento. E então, corrija o nome do bucket, GraphQL, que é CLI de barra
convincente. E também precisamos de alguns outros
plug-ins para este pacote. Então, novamente, co-general. E
precisamos do plug-in TypeScript. E também, novamente, a barra
GraphQL ou um traço co-gen corta os resolvedores
TypeScript. E execute esse comando. E agora, dentro do nosso arquivo
package.json, vamos criar
outro comando aqui e chamá-lo de generate. E vamos usar
o treinamento GraphQL. E então vamos especificar um arquivo de configuração e
chamá-lo de cogen dot YAML. Claro que ainda não
temos esse arquivo. Então, vamos criar dentro do diretório raiz e
salvar esse arquivo de configuração. Vamos especificar o caminho
do esquema. No nosso caso, está dentro
do diretório raiz, depois Schema dot GraphQL
e, em seguida, em generate. Vamos salvar nossos tipos gerados
dentro da pasta de origem. E, em seguida, pasta gerada paralelamente. E então diga que o arquivo txt do
tipo ponto do resolvedor. E agora temos que
especificar os plug-ins. Então, plugins, instalamos
o plug-in TypeScript e também os resolvedores TypeScript. E agora temos que adicionar algumas configurações
relacionadas ao TypeScript. Então, eu usaria a
assinatura de índice como verdadeira. E essa opção aqui nos permite gerar tipos dinâmicos de
TypeScript. Agora adicione dois pontos aqui
e salve esse arquivo volte para o
arquivo package.json e salve-o também. Então, vamos executar esse comando
no terminal npm, executar, gerar e esperar por ele. Tudo bem, geramos
com sucesso nossos divs dentro dos tipos de
resolvedores. Você pode ver que
temos nossa resposta de usuário e autor aqui em nossos tipos de entrada de inscrição de mutação. Sim, o usuário está aqui e
tudo está declarado. É claro que existem muitas configurações e outros
tipos relacionados à Graph Girl. Sim, então vamos fechar esse arquivo agora e voltar aos resolvedores do
autor e importar os resolvedores dos resolvedores gerados. Vamos fechar esse arquivo
e voltar aqui. Então, todos os três solucionadores usam esses
tipos enumerados que precisamos
importar da fonte ou
da pasta gerada. E a partir do arquivo de tipos de resolvedores, vamos importar resolvedores. E temos
que implementar esse tipo aqui. E agora podemos ver que todos os
erros do TypeScript desapareceram. Porque agora o
TypeScript sabe que a propriedade de mutação
tem um método de inscrição. No método de inscrição, há um resolvedor GraphQL
e seu rascunho, seu resolvedor
tem um pai, uma entrada e um contexto. E agora, se você escrever uma entrada
, receberá
sugestões do tipo de entrada de inscrição. Agora, vamos continuar criando
o método de inscrição. E eu só vou
retornar dados fictícios aqui. Então, precisamos devolver um documento de identidade. Ou, na verdade, você precisa
retornar uma propriedade do usuário. E dentro dele, teremos o ID do usuário e é
do tipo número. Vamos adicionar o ID1 e o e-mail. Então, vamos adicionar
um e-mail aleatório aqui e retornar o
nome e o sobrenome. Isso é apenas para testar,
porque devemos começar a trabalhar nos arquivos principal e no módulo e
testar nossos resultados. Agora, vamos
adicionar o sobrenome. Será
apenas fácil de usar e seguro. Então, na verdade, temos que
usar a entrada aqui. Temos que devolver a entrada vinda do
usuário, do cliente. Então, vou espalhar todas as propriedades dentro
do argumento de entrada. E você pode ver
que não temos nenhum erro no TypeScript. Então, isso significa que estamos retornando as mesmas propriedades que
existem para citar o usuário. Então você pode ver esse lado, o esquema dot GraphQL, temos a senha de e-mail, FirstName, LastName é
o tipo de usuário e o mesmo dentro das entradas de inscrição. É por isso que não
temos nenhum erro. Agora, ainda precisamos
devolver o token JWT. E esta vai
ser apenas uma sequência aleatória. Agora, se você percebeu, não
recebemos nenhum erro ao perder
o token JWT. Sim. E isso porque o
esquema de sábado, ponto GraphQL, não
adicionamos um ponto de
exclamação aqui. Portanto, temos que adicionar
isso ou tornar essas duas propriedades
necessárias e salvar esse arquivo. E agora temos que executar novamente
o comando generate para que
possamos garantir que
o autor resolva. Estamos retornando o
token JWT com a propriedade do usuário. Então, aqui
geramos o esquema, e aqui temos um erro do TypeScript dizendo
que estamos perdendo o DWT. Então, aqui, se adicionarmos
a propriedade DWT, a Terra desaparecerá. E, por enquanto, vamos
apenas enviar alguns dados fictícios. Depois de terminarmos os arquivos
principal e do módulo, voltaremos aqui e finalizaremos todas as
mutações e consultas. E isso porque ainda
precisamos nos conectar a um banco de dados e criar a entidade do usuário
dentro desse banco de dados. Dito isso,
no próximo vídeo, vamos começar a trabalhar no módulo e
nos arquivos principais.
11. Configure nosso servidor Apollo: Agora, dentro do
módulo, o arquivo ts, vamos configurar nosso servidor Apollo para trabalhar
com nosso esquema GraphQL. E o autor é solucionador. Então, vamos começar
importando alguns pacotes. primeiro é o servidor Apollo do Apollo server express e o import express
do Package Express. E também precisamos do
http do pacote HTTP. E você não precisa
instalá-lo porque nós o
temos por padrão com o NodeJS. Tudo bem, agora vamos exportar e criar uma nova classe
e chamá-la de módulo de aplicativo. Dentro dessa classe,
teremos um construtor que
aceitará resolvedores. Então, aqui, crie uma
variável pública e nomeie-a como resolvedores, e ela será
do tipo resolvedores. Temos que importar isso
da pasta gerada e
do arquivo de tipos de resolvedores. E aqui estamos recebendo um
erro porque precisamos importar e usar
resolvedores, não resolvedores. Então, adicione um S lá. E aqui vamos criar um método que iniciará
o servidor Apollo. Então, a cereja do bolo, Apollo. E esse método deve retornar. É claro que é uma promessa, e a promessa deve resolver um objeto com servidor HTTP, propriedade do tipo servidor HTTP. E temos que retornar um servidor ou propriedade do tipo servidor
Apollo. Agora vamos criar uma constante
e chamá-la de servidor, e usar a classe de servidor Apollo para criar uma nova instância de
servidor Apollo com algumas configurações. Então, aqui precisamos passar nosso esquema e resolvedores
do GraphQL. E vou
começar com os resolvedores e vou passar
essa variável aqui. E, claro,
estamos dentro de uma classe, então precisamos usar essa
palavra-chave e depois resultados. Agora, para o esquema, temos o tipo de propriedade de
mortes. E precisamos pegar esse arquivo, o esquema dot GraphQL, e passá-lo aqui. E para isso, vamos usar o método de sincronização
de arquivos de leitura de nossos pacotes from alphas. Então, aqui Leia o File Sync
e importe do fs. E antes disso, o servidor, vamos criar mortes
de tipo constante. E aqui vamos usar o Read File Sync
para ler o esquema GraphQL a
partir do esquema desse arquivo GraphQL. Então, deixe-me deletar isso. E aqui, vamos continuar. Precisamos especificar o caminho. E como temos esse arquivo esquemático do GraphQL
no diretório raiz, podemos escrevê-lo assim. Garota do gráfico de esquema. E vamos ler esse arquivo com a codificação definida como UTF oito. Porque sem a opção
de codificação, recuperaremos um buffer. Mas aqui precisamos de uma corda. Então, remova o cólon e dê ao tipo
mortes como esta. Agora temos que iniciar o servidor, então aguarde o início do servidor. E então precisamos criar
ou usar o middleware de aplicação. E aqui vamos
adicionar uma medula expressa. Então, vamos primeiro criar um aplicativo com o Express e
usá-lo aqui como um aplicativo medieval. Ok, agora, precisamos
retornar um servidor HTTP. Mas o aplicativo aqui
não é do tipo HTTP. Esse servidor
é do tipo expresso. Então, vamos usar os pacotes HTTP para criar um servidor HTTP
usando o aplicativo aplicativo, quero dizer, o aplicativo Express. Então, aqui, crie uma nova constante
e chame-a de servidor HTTP
e, em seguida, use http dot, crie um servidor e
passe o arquivo para lá. Então aqui, isso retornou o servidor HTTP com
o servidor Apollo. Agora, precisamos
iniciar uma nova instância e exportar do arquivo
do módulo. Então, aqui, exporte áudio
constante e, em seguida, crie uma nova instância
do módulo de aplicativo. Aqui temos que
passar os resultados. Portanto, temos que importar primeiro
o autor acabou. Então, aqui importe nossos resolvedores, e acho que não os
exportamos do arquivo ogres do
autor. Então, vamos fazer isso aqui. Exportar, exportar. O autor é solucionador. E então deixe-me copiar isso, voltar para um módulo e
importar os resolvedores do autor de sair ou dentro da pasta Earth e de
dentro dos resultados do autor. Agora, vamos voltar aqui e
usar os resolvedores aqui e depois salvar esse arquivo. E no próximo vídeo, vamos começar a trabalhar
dentro do arquivo main.js.
12. Execute e teste nosso Api: Dentro do arquivo main.js, precisamos importar
o módulo do arquivo
do módulo e, em seguida,
criar uma função bootstrap. E será assíncrono. E aqui dentro,
extrairemos o servidor HTTP e o servidor do módulo
que inicia um método de garrafa. Em seguida, usaremos
o servidor HTTP para iniciar ou começar a ouvir, pois as conexões são
ambas para milhares. Em seguida, retornaremos uma mensagem
ao console dizendo que servidor está pronto em
http localhost. E depois a porta 4.000. E aqui precisamos obter o caminho do gateway GraphQL
do servidor Apollo. Então, vou acrescentar aqui outra string
do servidor,
essa propriedade de caminho do GraphQL. E então obteremos o
caminho a para o gateway GraphQL. Tudo bem, agora, ainda temos que
executar a função
bootstrap chamada de função
bootstrap. E agora vamos salvar o arquivo
main.js, acessar o arquivo
package.json e adicionar
alguns scripts para executar nosso aplicativo. Então, aqui, crie um novo comando de
inicialização e teremos que compilar
nosso código e
executar o arquivo main.js. E desta vez
vamos usar o traço,
traçar a opção sem Ts, em vez de usar pacotes
Node man. E para usar essa opção, você precisa ter a versão
mais recente das notas. Sim. Então eu tenho a versão
19 que deve ter pelo menos 18. Portanto, certifique-se de atualizar
sua versão do Node.JS. Então, aqui, vamos o caminho
para o arquivo main.js. Então, esta pasta, depois a pasta de origem e
, em seguida, o arquivo dot js principal. E agora vamos pegar o comando TSO aqui e
colocá-lo em outro comando. Então, aqui, crie um comando de
compilação e cole o TSC lá. Então aqui vamos
executar o npm, executar compile. Então, compilaremos nosso código
e, em seguida, executaremos o arquivo main.js e observaremos as atualizações
ou as alterações. Agora vamos salvar o arquivo
package.json e os clubes. E aqui no terminal, vamos executar npm, run start. E temos um erro. E isso porque precisamos
adicionar uma consulta ao nosso esquema. Então, por enquanto,
não estamos usando consultas, mas vou adicionar uma consulta
muito simples. Então, aqui, sob mutação, vou executar ou criar um
novo tipo de consulta dentro dela, vou criar uma consulta
que retornará uma string. E aqui o esquema
define uma consulta. E aqui também
consulte e salve. E desta vez
precisamos regenerar os tipos e criar
um resolvedor para isso. Então npm run, generate. E então, dentro dos resolvedores do
autor. Vamos criar uma consulta
aqui e obter o método. Portanto, deve ser uma propriedade
e depois citá-la. Teremos o
método get e retornaremos apenas uma string. Então, vou enviar de volta
uma string LK e depois salvar e executar o
aplicativo novamente. Aqui, npm, corra, comece. Tudo bem, agora
temos nosso servidor no localhost 34,000 slash GraphQL. E aqui parece que
adicionamos uma barra, mas vamos corrigir isso mais tarde. Agora, vamos até nosso navegador e navegar
até localhost 4.000 GraphQL e clicar em Consultar seu servidor para que
possamos ter acesso. Estúdio fotográfico. E a partir daqui, vamos
testar nossas mutações e consultas. Tudo bem, agora estamos dentro da sandbox do Apollo e, raiz, você encontrará a
consulta e a mutação. Agora, começaremos eliminando a mutação e
tentaremos nos inscrever. Obviamente, temos dados fictícios, mas só testaremos o gateway
GraphQL aqui. Então, para adicionar a consulta de inscrição, clique no ícone de adição e você obterá a mutação e, em seguida, a inscrição com a entrada. E é assim que definimos
nossa mutação a partir da luz, do front-end
ou do cliente. Então, aqui, a entrada aqui é uma variável e é do
tipo Entrada de inscrição. Então, estamos obtendo esse tipo
do esquema, é claro. E aqui estamos definindo a mutação de inscrição
ou o método de inscrição. Sim, então esse é apenas o
tipo da mutação, e essa é a mutação real. E estamos adicionando ou configurando o argumento de entrada para ser
igual a, essa variável. E podemos, ah, editar a
variável de entrada a partir daqui. Como você pode ver aqui,
estamos dentro da
seção de variáveis e aqui podemos definir todas as variáveis
necessárias. Agora, dentro do método de inscrição, também
definiremos tipo de devolução e
o esquema GraphQL de
sábado. Você pode ver que a
mutação de inscrição retornará uma resposta e o outro cônjuge terá um campo de usuário
onde está o campo JWT. Então, aqui podemos especificar qual
propriedade vamos obter. Então, no nosso caso, vamos obter o usuário e nós apenas o interessante e o id. E então obteremos x, ou estamos esperando
o DWT. E é isso. Essa é a
coisa legal do GraphQL. Permite que você decida quais dados você
deseja obter como resposta. Portanto, em vez de retornar todo
o documento do usuário todo
o documento do usuário
com a senha
do e-mail, nome e sobrenome, podemos pedir
à recrutadora que devolva apenas o ID e também o token JWT, é
claro, porque o
usaremos para
autenticar o usuário. Agora vamos executar essa consulta clicando no botão
Inscrever-se aqui. E, claro, esquecemos
de adicionar a entrada. Portanto, essa solicitação falhará. Diz que a entrada da variável não
é, não deve ser nula. Então, aqui, vamos mudar isso. E em vez dos argumentos
aqui, seção de argumentos, podemos encontrar a entrada do
tipo Entrada de inscrição e você pode adicionar os
tipos necessários aqui. Então, deixe-me esclarecer tudo
isso em e-mail, senha
e nome, sobrenome. Todos eles são obrigatórios. Agora, para o e-mail
, escolheremos apenas o usuário em email.com
e, para a senha, enviaremos apenas a senha, o nome do usuário, e o
sobrenome do ano passado, usuário. Agora vamos enviar
novamente essa consulta ou essa mutação e
aguardar a resposta. Tudo bem, temos o ID de um e o token JWT
como essa string aqui. E você pode verificar se essa
string é a mesma string que
definimos dentro da instrução
return aqui. Então, o JWT ou propriedade. Portanto, temos nosso gateway GraphQL trabalhando com os servidores Express
e Apollo. E vamos
também testar rapidamente a consulta. Sim, então vamos
executar o método get, certifique-se de deixá-lo
lá e adicionar a consulta get. Então, adicione isso aqui
no getMethod. E para essa consulta, não esperamos
receber nenhuma entrada. Portanto, podemos simplesmente escrever o método get
assim sem parênteses, n sem nenhum argumento, depois executar a consulta e
devemos obter, ok, String. Tudo bem, temos isso aqui. E agora sabemos que todas as
nossas consultas e mutações estão funcionando e que
podemos executar nossos resolvedores. Agora, temos que
terminar de trabalhar
na mutação de inscrição e também concluir todos os resolvedores aqui. Mas antes disso, precisamos usar o type around para criar uma entidade de
usuário para que
possamos criar um usuário e
salvá-lo no banco de dados.
13. instalar e configurar o typeorm: Neste projeto,
usaremos o
type round para gerenciar
nosso banco de dados. Existem muitos
organismos por aí, mas o mais popular
é o tipo rampa. E isso porque ele
tem muitos recursos e é fácil de usar,
especialmente com o TypeScript. Agora, um OR é um mapeador
relacional de objetos. Você pode clicar neste
link aqui e ele o levará a
uma página da Wikipédia. E você pode ler mais sobre
mapeamento relacional de objetos aqui. Sim. Mas o TypeScript ou nossa rampa de tipos
significa TypeScript, object relational,
mapper e type around. É uma biblioteca que
facilita a vinculação nossos aplicativos
TypeScript a um banco de dados relacional. E no nosso caso, vamos usar o Postgres
como nosso banco de dados relacional. E, claro, os amplificadores de fraldas suportam muitos
outros bancos de dados, até mesmo o MongoDB, mas ainda estão
em fase experimental. Então, se você quiser usar o
MongoDB, você pode fazer isso, mas você precisa adicionar
muitas outras configurações. Porque, como você sabe, quando usamos o Mongoose, tivemos algumas dificuldades
quando queremos implementar o TypeScript
com modais do Mongoose. Sim, então a mesma coisa
acontece aqui com o diaper m, mas temos muitas outras
opções, como Postgres, C-Corps e my SQL ou sequel light e todos os outros bancos de dados. Agora você pode navegar até digitar o título do
parâmetro e aprender
mais sobre seus recursos. Mas é claro que, neste projeto, vou te ensinar
como instalar o tipo Rahm, como usá-lo, como
criar uma entidade, o tipo ao redor e
muitas outras coisas. Então, vamos abrir nosso VS Code. E dentro do terminal, vamos começar instalando o type around e o driver Postgres. E também precisamos de outro
pacote chamado reflectir metadados porque
vamos ou digitamos ou M está
usando os caracteres. E para usar os caracteres
com o TypeScript, precisamos instalar o
reflect me the data aqui. Então, sou eu, esses dados. Caso contrário,
obteremos, não poderemos
executar nosso aplicativo. Portanto, certifique-se de instalar isso. Além disso, se você não
instalou os tipos para anotar, certifique-se de fazer isso. Sim, eu instalei
isso desde o primeiro vídeo. Então, vou executar esse comando e
aguardar a instalação. Tudo bem, agora dentro
do arquivo main.js, temos que importar os
metadados de reflexão Beckett
para usar os caracteres. Então, deixe-me copiar isso. E a razão pela qual
você escolheu o main.js é
porque é o nosso
arquivo principal para este projeto. Então, vou importar
tudo da importação. Eles me refletem que
Theta está entre colchetes aqui. E temos que adicionar algumas
configurações aqui. E então a configuração ts diz
que é divertida. Então, precisamos adicionar mais
duas propriedades. primeira é a emissão, os caracteres, os metadados
e a configuração como verdadeira. E os
decoradores experimentais também definiram como verdadeiros. E essas propriedades são
muito importantes quando queremos executar ou usar os caracteres
dentro do nosso aplicativo. Agora, se você não sabe o que, quais são os personagens, aprenderemos sobre eles quando
começarmos a criar nossas entidades.
14. Criar entidade de usuário: Agora que temos uma
rampa de tipos dentro do nosso projeto, vamos começar criando
a entidade do usuário. Então, dentro da pasta, crie outra pasta e
nomeie-a como lado do usuário aqui, crie outra
pasta chamada entidade. E então, dentro
da pasta da entidade, crie o usuário, essa
entidade, o arquivo ts. Agora, aqui, vamos
importar a entidade do personagem do tipo wrap. E depois vamos exportar o nome de
uma classe, um teaser. E aqui vamos
usar a entidade decoradora. E é assim que definimos
entidades com diaper m. Agora, os caracteres são
apenas funções simples. Sim, That's retorna
outra função, mas também usa argumentos muito
específicos e eles precisam que o pacote de dados me
reflita para funcionar. Sim, então, se você
quiser criar um decorador, você pode pesquisar on-line, mas vou te dar um exemplo
muito simples. Então imagine que temos uma entidade aqui. Imagine que quiséssemos criar uma entidade, o personagem. Então eu vou fazer, vou criar uma constante
e chamá-la de entidade. E então eu vou
criar uma função. E essa função tem que
retornar outra função. Agora, a segunda função
aqui deve aceitar um alvo e aceitar
uma chave de propriedade. Para Tiki pode ser do tipo string e também
algo chamado distribuidor. Essa pegada aí. E este é do tipo descritor de
propriedade. Obviamente, não devemos usar o
distribuidor de funções para uma classe. É por isso que temos
um erro aqui. Sim, mas você pode
aprender mais sobre os distribuidores
na documentação. Por TypeScript aqui, você pode ler
mais sobre os personagens. Então copie este link e você poderá saber muitas coisas aqui
sobre distribuidores de classes, por exemplo ,
aqui, como os construímos aqui. Então, aqui criamos uma função
com um construtor. O construtor é
apenas uma função. E então usamos muitos métodos
JavaScript aqui para
manipular ou extrair
as propriedades e os métodos
da classe e fazer
algo com eles. Sim, agora, certifique-se de,
se quiser ler
mais sobre eles, vir aqui e, por exemplo tentar construir suas próprias ferramentas
ou seus próprios decoradores. Sim, mas por enquanto, vamos remover isso e continuar
com nossa entidade de usuário. Agora, precisamos de um primeiro nome
dentro de nossa entidade de usuário. Então, aqui, escreva o primeiro nome. E este vai
ser do tipo string. E certifique-se de que seja uma string
TypeScript. Quero dizer, com um s minúsculo. E precisamos usar
outro personagem aqui. E esse personagem
é chamado de coluna. Então, digite
a coluna a partir do texto e use-a aqui. Coluna. Agora temos o nome, o sobrenome, o
sobrenome do tipo string. E, claro, vou
usar a coluna novamente. E também precisamos
do e-mail do tipo string. E depois a coluna.
E o legal
do tipo onde m é que, mesmo se você usou um MongoDB
ou qualquer outro banco de dados, você pode definir,
você tem que definir as entidades sempre da
mesma forma com a mesma estrutura. Exceto para Mongoose. Porque, como eu disse antes
, ainda está em fase
experimental. Sim. E estava lá
há muito tempo, mas você ainda pode trabalhar com isso, mas precisa criar um esquema. Não podemos criar uma entidade
com Mongoose com fralda. Agora vamos continuar
com a entidade do usuário. Ainda precisamos da senha, e ela sempre
digite string aqui. E vou adicionar uma
configuração para a senha. E para fazer isso, podemos
passar um objeto aqui e dizer ou uma propriedade, selecioná-la e configurá-la como falsa. E isso significa que não
queremos , não queremos que a senha seja devolvida ao cliente. Sim, queremos ocultar a senha e é
assim que fazemos com o tipo. Agora podemos adicionar muitas
configurações, por exemplo, para o e-mail aqui, podemos. Eu mencionei que não
queremos que a imagem não seja. Então, usamos a
propriedade anulável e a definimos como falsa. Portanto, o e-mail não será: Não. É como uma validação
com fralda n, mas vamos usar outra forma de validação, uma forma
mais avançada. Sim. Agora ainda
precisamos da identificação aqui. Mas como a ideia é gerada
automaticamente
por posteriores, usaremos outro
decorador para definir o id e
que o caractere seja chamado de coluna gerada
primária. E aqui vamos
usar esse decorador. Portanto, a coluna primária é gerada. E aqui vamos definir o id. E, como eu disse para o PostgreSQL, vamos obter números de
ideias. Agora vamos salvar este
e o próximo vídeo, vamos criar
o serviço de usuário e começar a usar a
entidade do usuário. Então nos vemos lá.
15. Método de usuário | user.service: Agora, dentro da pasta do usuário, vamos criar outro arquivo e
chamá-lo de níveis de serviço do usuário. E aqui vamos exportar e
criar o serviço de usuário da classe. E depois vou
adicionar um construtor. E dentro dela
vamos definir uma variável pública e
chamá-la de repositório do usuário. E será do
tipo repositório. E vamos importar a interface
do repositório das máquinas
de escrever, assim por diante, o repositório
da rampa de tipos. E aqui no repositório. E temos que passar
a entidade aqui. Se você passar o mouse sobre isso, descobrirá que é necessário para
usá-lo em nossa classe. Então, aqui vamos adicionar
a entidade do usuário e
teremos que importá-la
da entidade de usuário do arquivo. Portanto, para cada usuário
da entidade do usuário ou
dentro do arquivo da entidade, use ou essa entidade. Agora, podemos começar
criando o primeiro método, que é o método create, qual criaremos um novo usuário. Então, Async create. E aqui, para os argumentos, será uma entrada de inscrição. E também usaremos
os tipos
gerados automaticamente aqui. O tipo da
mesma entrada aqui. Então, vamos atribuir o argumento de
entrada de
inscrição à entrada, interface e tipo de inscrição. E vamos importar isso de um nível para fora
e depois de dois níveis. E o Site
Generated selecionará o tipo de resolvedor e
a entrada de inscrição. E se você passar
o mouse sobre a entrada de inscrição, encontrará todas as nossas propriedades
necessárias aqui, como o nome e
sobrenome do e-mail e a senha. Claro, sem
o ID porque ele é, ele é
gerado automaticamente. E aqui corrija a assíncrona. Agora, a primeira coisa
que precisamos fazer dentro do método create é
criptografar a senha. Para isso, precisamos de
outro pacote. Então, vamos abrir o terminal. E vou parar o
Beckett chamado decrypt. E nós o usaríamos para
passar nossa senha e também comparar as senhas quando quiséssemos fazer
login no usuário. Então aqui, npm install the crypt. E também precisamos instalar
os tipos para, esteja correto. Em seguida, execute esse comando. Aguarde a instalação
e pronto. Deixe-me esclarecer isso e
fechar o terminal. E aqui, deixe-me abortar a aula
Big Rip da cripta. E aqui vamos
criar novas senhas,
uma senha com hash. Aguarde a criptografia. Esse hash. E aqui, vamos passar
a entrada de inscrição. Então inscreva-se aqui. Insira essa senha. E então precisamos
escolher uma rodada de sal. Então, aqui, vou escolher
dez como rodada de sal. E aqui estamos recebendo um
erro porque a senha, se você passar o mouse sobre ela, descobrirá que todas as
propriedades dentro do tipo de
entrada de inscrição não são necessárias. Para mudar isso. Temos que ir
para o esquema do GraphQL. Além disso, adicione um ponto de exclamação em
todas as propriedades aqui. E vamos fazer a mesma
coisa com o usuário. Portanto, precisamos apenas
da senha. Sim. Porque não
íamos devolvê-lo. E então ele define:
Vamos salvar isso. E precisamos abrir o terminal
e gerar os tipos. Então aqui, npm run, generate. E é isso. Deixe-me esclarecer isso ou
simplesmente fechar o terminal. Volte para o serviço do usuário e o erro desaparecerá. E agora a senha é do
tipo string antes de ser do tipo talvez ou
algo parecido. Eles usarão outra interface ou uma classe aqui para definir propriedades
não necessárias. Mas quando é necessário, estamos usando esse tipo aqui, mas é automático, degenerado. Não nos importamos com isso. Agora vamos continuar
criando o usuário. Agora, crie uma constante de usuário, use esse repositório de
usuário dot e seguida, crie o método
a partir do repositório do usuário. E aqui vamos divulgar o usuário ou a
entrada de inscrição, a entrada de inscrição. E então vamos
adicionar a senha aqui. Então, eu sei que dentro da entrada de inscrição já
temos uma senha, mas quando espalhamos as propriedades mais antigas como essa
dentro de um objeto e
adicionamos outra propriedade com o mesmo nome que existe
na entrada de inscrição. Na verdade, vamos
atualizar essa propriedade. E teremos
a senha definida com
esse valor para a senha
HashSet aqui. Agora, deixe-me, precisamos
salvar o usuário. E para fazer isso, precisamos usar esse método de salvamento de
pontos do repositório do usuário e passar o documento do usuário
recém-criado. Claro, vamos devolver esse documento ao cliente. Então, ele devolveu isso
e espere por isso. E depois salve. Agora, para usar o serviço de usuário dentro
dos resolvedores da Terra. E como o autor é
solucionador, é um objeto, não
podemos adicionar uma variável pública e configurá-la para o tipo de serviço de
usuário usuário. Portanto, precisamos criar
uma instância do serviço
do usuário e exportá-la para que possamos usá-la
nos resultados do autor. Sim, então, certo, exporte, depois serviço de usuário constante e adicione uma nova
instância de serviço ao usuário. E aqui precisamos passar pelo repositório
do usuário. E para isso, precisamos
criar a fonte de dados. E a partir da fonte de dados, obteremos
o repositório do usuário. Faremos isso
no próximo vídeo.
16. adicionar fonte de dados de aplicativo: Agora vamos criar
a fonte de dados do aplicativo e depois voltar aqui. Então, dentro da pasta de origem, crie um novo arquivo e nomeie-o, faça a fonte de dados, os Ts. E aqui temos que importar a
classe da fonte de dados da fralda. E aqui temos que
exportar uma constante, nomeá-la como fonte de dados. E será igual a uma nova instância da classe de fonte de
dados. E aqui vamos ter
o tipo do banco de dados. E no nosso caso, vamos usar o banco de dados
Postgres. Você pode ver aqui que
temos muitos bancos de dados, como eu disse antes, estou doente ou temos muitos
outros bancos de dados
como o MongoDB aqui. Então, para nós, vamos
usar o Postgres. E você tem que escolher o
Postgres neste projeto porque depois disso
vamos usar o Docker
para executar banco de dados
Postgres dentro do
nosso sistema local. Sim. Então, se você quiser
seguir este curso, você também precisa
escolher o Postgres. Agora, precisamos do host para
o banco de dados e, no nosso caso, vamos executar o
banco de dados no host local. E nós vamos
escolher o porto. E para o Postgres,
temos a porta 5432 e precisamos de um nome de usuário
para o banco de dados. Todas essas informações também
seriam adicionadas usadas quando
iniciamos nosso
banco de dados Postgres com o Docker. Então, aqui o nome de usuário
escolherá Admin. E para a senha, vou escolher também admin. E então o nome do banco de dados
, será o banco de dados principal. E agora temos que
definir nossas entidades. As entidades. É uma matriz que contém todos
os arquivos de entidades. Assim, você pode especificar o
caminho de sua entidade. Mas a melhor maneira de
fazer isso é primeiro desmarcar a
pasta dist e depois adicionar duas estrelas para escolher ou
pesquisar em qualquer pasta. E então adicione uma estrela aqui e,
em seguida, a entidade pontual que G tem. Agora, usando esse caminho, vamos selecionar todos os arquivos dentro da pasta
dist e dentro qualquer pasta que exista
dentro dessa pasta que tenha uma entidade de ponto no
final do nome. Sim. Agora, ainda precisa de mais
propriedades, como o registro. Não queremos receber uma sequência de consultas
dentro do nosso terminal. Então, para registrar,
vou escolher false. E precisamos adicionar a opção de
sincronização aqui. Mas certifique-se de
definir isso como verdadeiro somente para quando desenvolvermos nosso
banco de dados ou nosso projeto. E você pode ler aqui a
documentação dessa propriedade. E isso é um
aviso de que, se você usar a opção e
o modo de produção, perderá como
usará os dados de produção. Então, basicamente, nesta opção aqui, vamos atualizar o banco de dados. E como estamos
usando o Postgres, é um banco de dados relacional. Ele atualizará, a
seguir tabelas
do banco de dados
entre todas as entidades. Mas essa não é uma
maneira segura de atualizar o esquema. Portanto, nós só o usaremos. Use essa opção aqui. Em seguida,
trabalharemos com , adicionaremos pacientes e
eliminaremos essa opção aqui. Então, por enquanto, vamos mantê-lo definido como verdadeiro e voltar
ao serviço ao usuário. E temos que importar
a fonte de
dados, a fonte de dados de um nível para fora, dois níveis além da atualização. Então está lá e
vamos usá-lo aqui. Fonte de dados e, em seguida, repositório Git de
pontos. E temos que adicionar o alvo. E o alvo é
um tipo de entidade. Portanto, temos que passar
a entidade do usuário aqui para que possamos obter
o repositório do usuário. Agora, no próximo vídeo, vamos começar a trabalhar
com o autor em solucionadores. E vamos terminar
essa inscrição ou não, mas comece a trabalhar
nesse método de inscrição.
Então nos vemos lá.
17. Criar resolução de inscrição: Agora, dentro da mutação de inscrição, vamos remover esse código aqui. E a primeira coisa que precisamos
fazer é criar um novo usuário. Portanto, usuário constante do que
esperar pelo atendimento ao usuário. E ele pode pagar isso se
os usuários cortarem o serviço ao usuário. E então vamos usar o método create e passar a entrada ou
a entrada de inscrição. E para nós, é apenas
o argumento de entrada aqui. Agora, o tipo de retorno
da mutação de inscrição é objeto que tem um
campo de usuário com o campo JWT. Portanto, precisamos
criar um token JWT. E para isso, vamos
abrir nosso terminal e instalar o npm JSON Web Token. E, claro, precisamos dos tipos tipos JSON Web Token. E deixe-me esclarecer isso,
feche o terminal. E aqui temos que gerar um token JWT usando
o pacote JWT. Importe o JWT do token web JSON. Você sabe como fazer
isso, temos que usar o JWT em vez do método de login. Aqui. Vamos passar a carga útil. E desta vez vou
adicionar um payload com e-mail
da entrada desse e-mail e um ID de
usuário do ID do usuário. E precisamos de um token JWT. Portanto, temos que criar um arquivo de
tamanho de ponto e adicionar a variável de token
JWT lá. Então, no
nível do roteador do nosso projeto, vamos criar um arquivo. E aqui dentro uma chave JWT e adicione alguns caracteres aleatórios. E depois salve. Em seguida, precisamos do
pacote que
lerá os arquivos para nós dentro
de um projeto TypeScript. E esses são os colchetes. Então npm install dot. Então, isso é
seguro. Não salve o desenvolvedor. Deixe-me esclarecer isso agora. Feche o terminal e
vamos usar o ponto m que fica
dentro do arquivo main.js. Então, aqui eu importo
tudo como em. A partir daqui, vamos usar no gótico
e chamar esse método. E certifique-se de
importar isso na parte superior aqui para todas as
instruções de importação e, em seguida, Salvar. E aqui dentro do método
bootstrap, vamos verificar se temos um processo que está no token
JWT ou não. Sim. Então, se você não tiver a chave T GDB aqui, se você não tiver isso, retornaremos
ou geraremos um novo erro. E vai ter uma
mensagem que diz banco de dados. Tudo bem, agora vamos salvar isso, voltar aqui, fechar
o arquivo main.js e ir para o processo
que está nessa chave JWT. Portanto, temos que adicionar um ponto de exclamação aqui porque já
verificamos o arquivo main.js. Se não o fizéssemos, não
obtivemos a chave DWT. Quando executamos o aplicativo, geraremos um erro e não iniciaremos a API. Agora precisamos adicionar
um novo objeto aqui. E adicionaremos as
expirações na propriedade. E aqui podemos
definir a hora em que queremos que esse
token JWT expire. Então, no meu caso, quero expirar esse
token em sete dias. Assim, você pode escolher
quando quiser. Vamos salvar isso. E, claro, podemos adicionar
dias como esse. Se você passar o mouse sobre a propriedade exposta aqui,
verá que é, exceto por
exemplo, tempo
em verá que é, exceto segundos ou com apenas algumas
sequências como essa, dois dias ou 10 h, sete dias. Há muitas
maneiras de definir a hora aqui. Agora, depois de criar
o token JWT, precisamos retornar um objeto
com o usuário e o JWT, e ele será
definido como o token JWT. Agora, o erro
desapareceu porque estamos retornando o valor
correto aqui. E ainda precisamos
verificar se temos um usuário com o mesmo e-mail que já existe
dentro do banco de dados. Então, para isso, precisamos
criar um novo método
dentro do Serviço de Usuário. E será
chamado de encontre um por e-mail. E vamos receber
o e-mail como uma string. E então
retornaremos 08 e usaremos
o repositório do usuário para encontrar um rapidamente,
o e-mail aqui. Agora salve isso e
volte para os resolvedores. E aqui, crie uma nova
constante e nomeie-a como usuário
existente ou existente. E aqui vamos
usar o Serviço de Usuário que encontra um por e-mail e o
e-mail a partir de inserções desse e-mail. E precisamos esperar por isso. E depois salve. E precisamos verificar se
temos um usuário existente e,
em seguida, precisamos
corrigir um erro. E para o erro, precisamos usar um tipo muito
específico de
erro que
vem do ou com o GraphQL. E isso é um GraphQL. E podemos importá-lo
de um acordo gráfico. Sim, então se você não
instalou o gráfico aqui, certifique-se de instalá-lo e também
instalou os tipos para o GraphQL. E aqui precisamos
adicionar uma mensagem. Portanto, a mensagem
será que o usuário já existe. E podemos simplesmente enviar uma mensagem de volta ou adicionar outras configurações, como a extensão
ou as extensões. E aqui podemos adicionar o
código desse erro. Então, outro objeto
aqui, propriedade Code. E vou
devolver um código de solicitação incorreto. Então, se você quiser enviar volta algumas informações
sobre esse erro, como talvez os campos ou
o tipo de erro como este. Você pode adicionar tudo isso dentro do
objeto de extensões aqui e ele será enviado
ao cliente. Claro, se você quiser
criar um erro
personalizado crie o
mesmo que fizemos nos outros dois projetos. Crie uma
classe separada para seu erro. E, claro, você ainda
precisa usar o GraphQL aqui para criar essas classes. Mas isso realmente não é
necessário porque
já temos uma classe
e podemos usá-la sempre que quisermos
gerar um erro. E será analisado conforme
o gráfico, ou sim, não
precisamos criar
nenhuma nova classe a partir disso. Agora, isso é tudo para
o método de inscrição. No próximo vídeo, vamos
criar o login.
18. Criando o resolver de sinal: Agora não podemos trabalhar no
sinal de uma mutação aqui. Portanto, os resolvedores,
porque ainda não definimos o sinal
das mutações, são o esquema. Então, primeiro vamos fazer
isso e depois voltar
para os resolvedores da Terra. Aqui mesmo. Vamos definir a mutação, vamos criar o
site em mutação. E obteremos uma entrada
do tipo, entrada de login. E, a propósito,
podemos usar outra
estrutura aqui. Então, em vez de adicionar um argumento e a hora
para esse argumento, podemos definir todos
os argumentos aqui, como um e-mail do tipo string. E é obrigatório. Em seguida, adicione uma vírgula e
precisamos de uma senha como uma string. Sim, mas como estamos usando
os tipos também dentro de
nossos resolvedores, dentro de nosso serviço de usuário, precisamos definir seu
tipo de entrada como um objeto aqui. Então, vamos mudar isso para
inserir uma entrada de login, e essa será necessária. Novamente, vamos
retornar uma resposta terrestre. E, claro, é obrigatório. Agora, precisamos adicionar
o login aqui, entrada que é criada aqui. Entrada e entrada de login. Só precisamos do
e-mail como uma string, e ele é adquirido
com a senha como uma string obrigatória. Certo? Agora, vamos salvar isso
e abrir o terminal. E temos que
gerar o esquema. Então npm run, gere originário
o tipo do esquema. Tudo bem, agora feche o terminal e feche o arquivo GraphQL de
pontos do esquema e volte aqui dentro
dos solucionadores do autor. Abaixo do login. Vamos definir o ou
abaixo da inscrição, vamos definir o método de login. Devemos obter uma sucessão
para esse método aqui. Espere um segundo aqui. Faça login. E se você passar o mouse sobre ele, verá que seno
n é do tipo resolvedor. Então, geramos
os tipos corretamente. Então, aqui, isso define a
entrada atual e os contextos. E, como eu disse antes, vamos falar
sobre os contextos e apenas os vídeos futuros. Sim, então aqui
temos que verificar se
temos um usuário com esse e-mail
salvo no banco de dados. Então, vou copiar
essas duas linhas aqui do
método de inscrição e colá-las aqui. E mude isso apenas com o usuário. Aqui. Se não tivermos,
se não
tivermos um usuário, enviaremos de volta
um erro longo escrito. Então, aqui, errado, os potenciais do Cree, externo e o código
ainda são uma solicitação incorreta. E então temos que
verificar se temos, se as senhas
dentro da entrada são iguais à senha de risco do banco
de dados do usuário. Então, vamos adicionar uma constante
e chamá-la de PWD correta, e então aguardar pela cripta B. E temos que importar isso. Então esse cão Alport classe
corrompida dos pacotes de decodificação. E aqui vou usar
o método compare. E esse método
aceita o buffer ou a entrada e depois a compara com a senha
ácida. Sim. Então, insira aqui a senha. E então obteremos a senha perigosa
da senha do usuário. Mas, no nosso caso, não
podemos obter a
senha do usuário. Isso porque dentro da entidade
do usuário, dissemos o chavão
canon, selecione false. E é por isso que chegaremos
aqui e definiremos ou não. Sim. Mas podemos mudar esse
site, o serviço ao usuário,
e, em vez disso, eles encontram um por
e-mail que o removeu, encontrar um por método. Aqui. Vamos criar um criador de consultas. Então, no repositório do usuário, crie um construtor de consultas. E aqui vamos
declarar uma variável
e chamá-la de usuário. E igual ao
construtor de consultas. Aqui. Adicione ideias para o usuário
e, em seguida, usaremos um método para selecionar a senha do usuário. Então aqui, a senha do usuário,
agora a consulta. Mas há um método
que ajuda na criação consultas
SQL apenas adicionando
outros métodos como esse. Sim, então vamos criar degenerar uma
consulta sequencial aqui usando o Query Builder para
selecionar a senha do usuário. E então vamos encontrar ou selecionar um usuário em que o e-mail seja igual a e-mail. Aqui, definiremos
a variável e-mail. Então, o que
está acontecendo aqui é que vamos verificar se o e-mail é igual
a essa variável, sim. E para definir variáveis
dentro dessa consulta aqui, adicionamos os dois pontos e depois
o nome da variável. E então, no
segundo argumento aqui, temos um objeto contendo os valores dessa
variável aqui, e ela deve ter o
mesmo nome que escrevemos aqui. É por isso que, quando executamos
o construtor de consultas aqui, ele será alterado para email equals e, em seguida, para
o e-mail do usuário. Agora, precisamos de outro método
aqui para obter um usuário. E se você passar o mouse sobre o usuário agora, verá que esse usuário é uma promessa que retornará
um usuário ou não. Portanto, precisamos
esperar aqui, e desta vez
teremos um usuário ou não. E nesse caso,
vamos devolver o usuário e salvar
o serviço do usuário. Volte aqui. Ou, na verdade, vamos voltar
ao serviço ao usuário. E aqui, esqueci de mencionar que devemos adicionar
uma seleção aqui. Sim, essa será
a
seleção principal e vamos
selecionar documento do usuário ou todas as colunas em vez do documento
do usuário. Em seguida, adicionaremos uma seleção onde
usaremos a senha. E então faremos o filtro aqui e depois enviaremos de volta o
usuário com a senha. Agora, infelizmente,
a força de seleção aqui apenas oculta a senha
dos métodos de busca. Então, encontre um ou
encontre por alguma coisa. Sim, mas não
esconde a senha. Quando salvamos o usuário aqui
ou salvamos uma nova entidade. Portanto, precisamos
criar uma constante aqui
dentro do método create. Crie uma constante que
contenha o usuário do serviço
e, em seguida, crie outro
método Find depois disso aqui. E procure o
usuário com o ID. Sim, mas isso vai
ser uma perda de tempo, especialmente quando se
trabalha com o GraphQL. Porque com o GraphQL,
podemos ocultar senhas ou qualquer coisa simplesmente
removendo os campos aqui. Portanto, para senha, podemos
remover o campo de senha. E então, dentro
da resposta desativada, dentro do usuário,
não obteremos a senha. É assim que ocultamos
credenciais usando o GraphQL. Mas aqui eu só queria
mostrar como você pode obter um campo de altura do banco de dados usando
o
Create Query Builder se você não estiver usando o GraphQL. Então, vou deixar esse
código assim apenas para você se lembrar de como
obter um túnel alto, como a senha
e a triste entidade de usuário Vou remover o select false aqui
porque não
quero alterar ou escrever o mesmo código toda vez
que quiser obter a entidade. E vou adicionar um nível dois
comum. Para indicar isso, você pode usar essa abordagem
somente quando estiver se escondendo. Então, aqui, somente se a entidade que Carlin e você tiverem
a seleção definida como falsa. Agora salve o serviço do usuário feche esses dois arquivos
e volte aqui. E isso é uma continuação muito rápida
com o método de login. Então, agora precisamos
verificar se não tínhamos ou não obtivemos
a senha correta e, em
seguida, retornaremos um erro. E aqui estou sentindo falta do ar, corrigir ou ver e ouvir, lançar um novo erro da garota gráfica. E será
a mesma mensagem que você
credencial, credencial errada. E a mesma extensão. Então deixe-me copiar isso. E aqui vou
copiar a extensão. E então temos que regenerar o token JWT e depois retornar
o usuário com o JWT. Então, vou copiar
isso e colar aqui. Agora, o usuário será
retornado com a senha. Mas, como alteramos
isso dentro do esquema, não
retornaremos ou
a engrenagem gráfica não
selecionará a senha
da declaração
de retorno das mutações aqui. Agora, é claro, você precisa
abrir seu terminal e executar o npm run degenerate porque
atualizamos o esquema. Então, vamos fazer isso. Npm run generate. E é isso. Terminamos de trabalhar
no método de login.
19. trabalhando com o contexto do graphql: Agora vamos
criar uma consulta que retornará o
e-mail do usuário e o ID do usuário. E, novamente, vamos
começar com o esquema. O GraphQL e o crea criam
uma nova consulta e a
chamam de usuário atual. E aqui vamos
devolver uma carga útil do JWT. Agora temos que definir esse tipo. Então copie o nome do JWT
e aqui crie o tipo, depois o JWT, desapareça e cite. Teremos o
e-mail do tipo string e teremos o id de
usuário do tipo int. E os dois são obrigatórios. Agora vamos salvar isso, fechar o esquema do GraphQL
e temos que gerar os tipos. Execute npm, execute, gere e feche o terminal. Volte para os resolvedores do autor. E aqui dentro da consulta, vamos remover o
método get daqui. E o método atual do usuário. Ouvindo isso. Pai, precisamos
da contribuição e dos contextos. Tudo bem, agora temos
um erro aqui porque
não adicionamos uma variável de entrada
à consulta do usuário atual, como se não tivéssemos
atribuído a mutação, então não obteremos um argumento
de entrada aqui. Então, vamos remover isso e
substituí-lo pelo nosso x assim. E só para deixar claro que não
temos nenhum argumento, vou substituí-lo
por um objeto vazio. Tudo bem, agora
vamos extrair a carga útil
do JWT
do token JWT. Mas costumávamos adicionar
essa lógica dentro um middleware e depois usar esse middleware
dentro de outros roteadores. E, em seguida, obtenha um objeto
das solicitações que contêm
a carga do usuário. Mas é claro que isso está
dentro de uma API RESTful. Mas como estamos usando o
Express com o GraphQL, podemos fazer a mesma coisa. Podemos adicionar. Podemos usar um Create
Image e, em seguida
, usar o método 2s para
aplicar o Centro-Oeste aqui. E então obteremos o, podemos extrair a
carga útil do JWT do token JWT. Mas podemos implementar o mesmo processo com o servidor
Apollo adicionando contextos que conterão a solicitação e os payloads
do JWT. Então, aqui, digamos o
servidor Apollo em um contexto. E
será uma função que retornará um objeto. Agora, antes de começar a trabalhar
nessa função, precisamos adicionar uma nova interface
e nomeá-la como contextos. Então, aqui, interface de exportação,
depois meu contexto. Precisamos estender o conteúdo do Express para que possamos
ter acesso à solicitação. E aqui vamos adicionar
nossas propriedades personalizadas. Mas primeiro, precisamos
importar os contextos
do Express do servidor Apollo. Então, aqui, o
contexto do Airport Express a partir de uma foto
do Server Express. Agora, aqui, essa é nossa
primeira propriedade personalizada, que é o usuário atual. E será de carga útil do
tipo T, W T. E a carga útil do DWT é importada dos tipos incinerados. Portanto, certifique-se de importar
isso desse caminho aqui. Em seguida, temos que adicionar
outra propriedade, que é a propriedade
autorizada. E com essa propriedade, podemos verificar se temos um usuário
autorizado ou não. Portanto, essa propriedade será
do tipo Boolean. E salve isso. Volte aqui. E precisamos adicionar a interface de contextos do microfone
com o servidor Apollo. Então, vou retornar o servidor Apollo com meus contextos do
tipo, meus contextos. Tudo bem, agora, volte
para esse método aqui. E agora podemos extrair. Da disfunção,
extraia a solicitação e a resposta porque
ampliamos os contextos do Express. E aqui, vamos criar uma
constante e chamá-la de payload, e depois usar os
pacotes DWT do DWT, temos que importar isso. Então, vamos fazer isso. Importante: o token JWT
do Jason está aqui, CWT não
verifica para verificar o token. E vamos receber
o token desta vez, não da sessão, mas dos cabeçalhos. Portanto, usaremos a
carga útil da solicitação ou os tethers. Certifique-se de selecionar
cabeçalhos, sem amarras. E então vamos obter o token do cabeçalho de
autorização. Sim. Então, o Heather pode ser não. Então, vamos adicionar um ponto de
interrogação lá. E agora precisamos passar a chave secreta
do JWT. Então, posso obter isso
processando a tecla DWT e adicionar
um ponto de exclamação. Portanto, podemos dizer ao TypeScript
que isso não é nulo. E agora precisamos devolver
essa carga aqui. Portanto, faça um pedido aqui, porque parece
que
a solicitação também pode ser nova ou indefinida. Então, vamos adicionar um ponto de
interrogação lá. Ou vamos verificar se não
recebemos uma solicitação. Sim, devolveremos um objeto e
voltaremos aqui em apenas um segundo. Agora vamos definir a propriedade do usuário
atual e atribuir a ela a carga útil. Em seguida, também enviaremos volta ou repassaremos a solicitação
aos resolvedores. E então nós vamos para a propriedade
autorizada, e a
propriedade autorizada é booleana. Então, vamos verificar se você
tem uma carga útil ou não. Então, se você não recebeu um pagamento significa que o usuário não
está autorizado. Então, para isso, vou
usar uma sintaxe especial. Então, nossos dois pontos de exclamação
e depois Abby pagou. Portanto, se a carga for
nula ou indefinida, o primeiro ponto de
exclamação retornará verdadeiro. Então, o segundo ponto de
exclamação retornará o oposto
de verdadeiro, que é falso. E então eles autorizaram, será definido como
falso, significa que o usuário não
está autorizado porque
temos um nulo, um piloto. Agora, se não
tivéssemos uma solicitação
, isso é um problema para nós, porque não podemos
extrair o token JWT. Então, vamos enviar um
no mesmo objeto, mas
com o seletor coreano definido como
nulo e a solicitação, é
claro, e o
autorizado como falso. Temos que devolver isso. Tudo bem, agora, vamos remover
os pontos de interrogação daqui. E, na verdade, aqui
temos que verificar se não recebemos ou não temos um cabeçalho de solicitação de
autorização aqui, então enviaremos de
volta esse objeto. Caso contrário,
extrairemos a carga útil e enviaremos a propriedade necessária. Agora, deixe-me ajustar um pouco esse
código para fazer isso e salvar esse arquivo. Em seguida, feche-o e
volte para o resolvedor ou consulta
do usuário coreano aqui. E vamos verificar
se a propriedade autorizada está
dentro do contexto. Verdadeiro ou falso. Sim. Então, se a
propriedade autorizada está aqui autorizada. E não estamos obtendo a
autorização do contexto. Isso porque precisamos
atualizar a cadeia de código aqui. Sim, e atualize os
tipos de resultados. Portanto, precisamos especificar o tipo de contexto e dizer
isso na configuração aqui. E no mesmo nível de
indentação, contextos, tipo ou contextos, digite por
tipo e especifique o caminho ou o arquivo que
contém nosso contexto. No nosso caso, meus contextos existem dentro do arquivo do módulo. Portanto, certifique-se primeiro de exportar
a interface de contextos do microfone e vir aqui e adicionar o nascimento de acordo com a
pasta gerada. Portanto, de acordo com a pasta
gerada, o módulo ou de acordo com o tipo de resolvedor existente ao lado da pasta
gerada. O arquivo do módulo está a um
nível, depois o módulo. E temos que selecionar
a interface. Então, vamos adicionar uma hashtag aqui e adicionar o nome
dos contextos. Então, meus contextos. E nesse caso, estamos selecionando a, a,
uma interface
ou variável exportada do arquivo usando
uma sintaxe YAML. Agora vamos fechar o arquivo de configuração
co-gen e abrir o terminal. Então aqui temos que executar
os comandos do gerador. Então npm run generate, e então obteremos nosso
contexto de tipo, meu contexto. Sim. Então, vamos esperar. Agora mesmo. Se você passar o mouse sobre os contextos, deverá digitar os
contextos da bicicleta aqui. Agora deixe-me fechar o terminal e a autorização é
do tipo Boolean. Então, vamos verificar se
o usuário não está autorizado e,
em seguida, enviaremos de
volta um erro não autorizado. Então, Throat sabia que o GraphQL
e o MS não estavam autorizados. E precisamos adicionar uma extensão. Extensão. Em seguida, adicione o código. E aqui vamos adicionar o código. Não autorizado. Tudo bem? Agora, se tivermos uma autorização
para
esse usuário ou retornarmos do
contexto, o usuário atual. Agora vamos economizar. O usuário atual é do tipo G. A carga útil do deputado contém
o e-mail e o ID do usuário. O nome do tipo é apenas
algo relacionado ao GraphQL. Mas dentro do
esquema do GraphQL ou de uma resposta, obteremos apenas
o e-mail e o ID do usuário. Tudo bem, agora vamos salvar isso. E para testar todos
esses resolvedores aqui, precisamos ter um banco de dados
funcional. Então, nos próximos vídeos, aprenderemos como
usar o Joker, é claro, como instalar o Docker
e depois usar o Docker para instalar o banco de dados Postgres e executá-lo em nosso sistema local.
20. o que é o Docker: Docker divide um sistema Linux em
execução em pequenos contêineres, que são seu próprio mundinho
com seus próprios programas
e tudo o que é próprio,
tudo isolado de qualquer outra coisa. Esses contêineres são
projetados para serem portáteis que
possam ser deslocados
de um lugar para outro. E o Docker faz o
trabalho de levar esses contêineres de
e para seus sistemas. Agora, o que é o contêiner? Você sabe, quando você cria
algo com, por exemplo um OTS e depois envia
seu código para o GitHub e outra pessoa
tenta extrair e executar seu código dentro do sistema local
dele, mas não funcionou para ele. E então ele pensará
que seu código é lixo. E você também pode pensar que
não é um bom desenvolvedor. Mas às vezes esse não é o
caso, porque seus
aplicativos Node.JS exigem um software
muito específico e um ambiente exclusivo para funcionar. E esses requisitos
só existem dentro do
seu sistema local, onde você está,
onde desenvolveu seu aplicativo Node.JS. se você tem
Linux e, em vez de Windows, ou tem uma versão
mais antiga dos nós, sim, todas essas variáveis não podem ser iguais
em todos os sistemas. Portanto, o Docker
introduziu algo
chamado contêiner. Um contêiner é uma
unidade padronizada de software que permite que os desenvolvedores acessem
facilmente
seu ambiente. Assim, você pode desenvolver, por exemplo seu aplicativo Node.JS,
criar um contêiner em torno dele e enviá-lo para o
Docker Hub como uma imagem. E então qualquer um pode extrair essa imagem e executá-la em
seu próprio sistema local. Nesse caso, seu aplicativo
NodeJS será executado no
mesmo ambiente do sistema local.
21. Instalar docker Linux: Agora, para iniciar o Docker em sua janela ou no
sistema Linux em geral, você precisa seguir algumas
etapas. Então, veja etiquetas mais escuras. E você pode usar esse
caminho aqui ou esse URL. E talvez você possa
pesquisar no Google para instalar o mecanismo Docker
em seu pinto, pois URLs podem ser alterados
no futuro. Agora, a primeira coisa que
você precisa fazer aqui é garantir que você não tenha nenhuma
versão mais antiga do Docker. Ao executar esse comando aqui, você pode excluir todas as versões
desatualizadas. Agora, a próxima etapa é atualizar seus pacotes APT. E então vou começar com
alguns mendigos e ver se isso será
usado nas próximas etapas. Sim, então você
precisa executar esses comandos para dizer ao seu sistema
que não há problema em usá-lo. O software é
do Docker Engine. E então você precisa executar esse comando para
configurar seu repositório. E a razão pela qual
precisamos adicionar nosso repositório ou
configurar um repositório conectado ao
Docker Engine é porque
vamos extrair imagens
do Docker Hub. E às vezes precisamos
enviar imagens feitas por
nós para o Docker Hub. Então, precisamos de aeroportos,
era assim. É semelhante aos repositórios
com o GitHub. Sim. Agora, a próxima etapa é
instalar o Docker Engine. Depois de configurar
seu repositório. Obviamente, você precisa
atualizar seus pacotes novamente. E se você tiver algum
erro, execute esses comandos. E, finalmente, você pode instalar o Docker
executando este comando. Depois disso, se você
quiser verificar se instalou o Docker com sucesso, você pode executar uma imagem
que existia por padrão com o Docker
chamada kilowatt. Então, execute este comando, sudo docker run hello-world, e você deve
recuperar uma string com HelloWorld.
22. Imagens para recipientes: Agora que instalamos o
Docker e conversamos um pouco
sobre o que é o Docker, vamos tentar usá-lo. Então, com o Docker, tudo
começa com uma imagem. Uma imagem é cada
arquivo que compõe apenas o suficiente do sistema
operacional para fazer o que você precisa fazer. Agora, o comando para
examinar suas imagens do Docker
é simplesmente imagens do Docker. Você pode ver aqui
que eu tenho muitas imagens e coisas acontecendo aqui porque eu costumava
ocorrer o tempo todo. E para você, você pode ter algumas imagens como as que você
já visitou ou HelloWorld. Agora sua imagem tem um
nome e uma versão, bicicleta mais recente ou
algo parecido. E sua imagem também tem um ID. E aqui podemos descobrir quando
essa imagem foi criada. E aqui você pode ver
o tamanho dessa imagem. Agora, vamos pegar uma imagem e executá-la dentro do
contêiner usando o Docker. Deixe-me limpar este terminal
e, em seguida, executar o docker direito. Execute o comando. Agora, esse comando pega uma
imagem e a transforma em um contêiner vivo em execução com um processo que está
fazendo alguma coisa. Agora, após a execução do docker, vou especificar a
imagem que eles desejam usar. E para mim, vou
usar quem já visitou. E para você, se você
não descobriu que foi instalado por
padrão no seu coringa. Não se preocupe porque, ao
executar esse comando, o Docker tentará
puxar o humano para a imagem com a
versão mais recente do Docker Hub. Então, é claro que você precisa ter uma conexão com
a Internet para fazer isso. Agora, ainda não
terminei este comando aqui. Então, docker run, você já esteve. E então dissemos
que vamos
executar um processo nesta imagem. Então, vamos executar o shell
bash porque eu quero executar alguns
comandos dentro de você usando com o terminal. E também para isso, precisamos de uma bandeira para interagir
com o terminal. E a bandeira é a bandeira D. Então D significa
terminal e I significa interativo,
terminal e diretivo. Então você foi criticar. E agora vamos executar esse
esquema para você. Se você ainda não visitou, você verá um processo de
download. Tudo bem, estamos dentro
da imagem do Ubuntu. Agora, se eu der uma olhada aqui, descobrirei que estamos
dentro do ambiente em que temos o, você esteve no ambiente. E só para
ter certeza de executar este comando para dar uma olhada neste arquivo LSB dash release. E devemos obter a versão que você vai ter aqui, a versão 20 e
o ID de distribuição. Agora você vai
sair desta imagem. Você pode escrever exit assim
ou Control D faz para exit. Agora, para ver
a última imagem que saiu, podemos abrir um novo terminal aqui e docker ps e
, em seguida, marcar mais recente. Então, se você executar apenas
ps, você descobrirá que obterá todas
as imagens em execução. E com L, você pode obter
a imagem mais recente que saiu. Se você executar esse comando,
descobrirá que a imagem é a que você já visitou. E você encontrará o comando aqui que estava executando o
site this image. E, claro,
onde o cria? E saiu há
cerca de 4 minutos. Sim. E esse não é o nome
desse contêiner, nem a imagem. Portanto, esse contêiner está
percorrendo o urbano para criar imagens e administrar
a cesta. Sim. E foi criado
há 6 minutos e encerrado há 4 minutos. E essa é a ideia
do contêiner. E eles disseram o nome
do contêiner. E, a propósito, esse nome é gerado
aleatoriamente pelo Docker. Agora vamos voltar
aqui e executar a imagem, você já esteve na imagem
com o shell bash. E por dentro
você já esteve na imagem. Vamos criar um novo arquivo com o comando touch
e chamá-lo de meu arquivo. E dê uma olhada aqui e
encontraremos meu arquivo. Então, vamos sair com isso. Ou deixo pular a
execução desse contêiner e voltar aqui e, em seguida, executar
o mesmo comando, docker, executar TI para
terminal interativo. E então você acessou
e executou o shell bash. Então, estamos executando
a mesma imagem com o mesmo sinalizador
no mesmo processo. E aqui, se dermos uma olhada, não
encontraremos o arquivo
que foi criado aqui. Portanto, seu contêiner
executa uma imagem e não
é afetado por outros contêineres que
executam a mesma imagem. Então, quando criamos um arquivo aqui, não significa que
vamos obter o mesmo arquivo dentro desse contêiner que
executa a mesma imagem. Portanto, seu recipiente é
isolado do outro. Mesmo que ambos
tenham a mesma imagem, você pode pensar neles como dois computadores executando a mesma
versão que você já usou.
23. recipientes para imagens: Agora podemos ver que passamos de uma imagem para um contêiner
em execução. E quando iniciamos um contêiner, o contêiner ainda está lá.
Não foi excluído. Assim, posso ver o contêiner que
saiu mais recentemente com um comando docker ps. Mas é claro que precisamos da bandeira dash l para obter o
último contêiner parado. Então, aqui você pode ver que eu tenho um contêiner que estava
funcionando há pouco. E você pode ver todas
as informações sobre esse contêiner aqui. Agora, digamos que eu tenha
um contêiner parado. Comecei com uma imagem base. Ion iniciou meu próprio software. Eu tenho um contêiner que tem meu software instalado nele. Agora, quero usar o
mesmo contêiner que tem meus próprios softwares
no futuro, ou talvez compartilhá-lo
com a comunidade. Então, para fazer isso, temos que usar o comando docker
commit que pega contêineres e
cria imagens a partir deles. Então, para usar o docker commit, vamos primeiro criar um novo
contêiner. Vamos esclarecer isso. E um. Você já esteve, é
claro, com a bandeira TI e depois acessou e
executou o comando batch. Agora, dentro desse contêiner, vamos criar um arquivo e precisamos usar esse arquivo no futuro
com esse contêiner. Então, vamos
criar uma imagem
desse contêiner aqui que está usando o comando touch e criar um arquivo e nomeá-lo como segredos. Temos nosso arquivo aqui. Vamos sair desse contêiner com o Controle D ou
simplesmente escrever exit. E então vamos pegar a ideia desse contêiner
executando docker ps dash L. Então temos aqui
a ideia desse contêiner. Então, vamos copiar esse id. E então vamos usar o comando
docker commit e colar o darker ou
o ID do contêiner aqui, depois executar o comando docker
commit. Agora,
tiraríamos uma imagem desse contêiner. E essa é a
ideia dessa imagem. Mas usar um ID longo como esse não
é bom
porque você pode perder esse id ou talvez tenha
dificuldade executar comandos usando
essa string longa. Então, o que vou
fazer a seguir é marcar essa imagem com
um nome legível por humanos. E para fazer isso,
não usamos a bandeira de tag. Em seguida, adicionamos o ID
dessa imagem
dos dois pontos até o final dessa
string e colamos aqui. E então escolha um
nome para essa imagem. Então, imagine o que, por exemplo e execute o comando Docker. E agora, se quisermos verificar
se você tem uma imagem com o traço da imagem ou
sublinhado em um nome, você pode executar imagens do Docker e pesquisar
o nome da
imagem aqui. Você pode encontrá-lo aqui. Então, temos a imagem sublinhada um, e aqui temos o ID. E foi criado
há minutos. É assim que podemos criar
imagens a partir de contêineres. Agora, há outra maneira de
confirmar imagens em
vez de usar o
comando commit. E é perspicácia. E isso é, antes de tudo, criar um contêiner Docker e pegar a ideia
desse contêiner. Em seguida, vamos usar o
docker commit de outra forma. Então, aqui vamos criar
um arquivo como meu arquivo. E vamos sair novamente. E então vamos
verificar ou ter uma ideia desse contêiner
docker. E agora podemos pegar o
nome do contêiner. Aqui, um nome legível por humanos, copie-o e execute docker,
commit, depois o nome
do contêiner
e, em seguida,
o nome da nova imagem que
você deseja criar. E desta vez vou escolher
a imagem dois. Agora estamos executando esse comando. Obteríamos a mesma
saída de antes. Mas se você executar imagens do
Docker agora, poderá encontrar uma imagem para ser apresentada em nosso repositório
local do Docker.
24. executando o banco de dados postgres com docker: Agora vamos aprender
mais sobre o docker
e, ao mesmo
tempo, vamos
executar nosso banco de dados Postgres. E para isso, precisamos extrair a
imagem SQL postgres do Docker. Para fazer isso, temos que
executar docker, pull. Em seguida, o nome da
imagem que é Postgres. Você pode adicionar dois pontos e
depois a tag mais recente. Mas, por padrão, instale a versão mais recente. Agora não vou executar
esse comando porque
já tenho essa imagem
no meu sistema local. Agora vou
usar o
comando docker run para executar a imagem
postgres. Claro, com a bandeira DI
aqui e a imagem postgres. Agora, não vamos
executar esse comando. Faça isso porque precisamos
adicionar algumas configurações. E desta vez eu quero adicionar um nome personalizado
para o meu contêiner. E para isso temos que usar o desktop chamado flag e depois escolher um nome como
up. Sublinhado. Ambos são estressantes. Agora, para estabelecer uma conexão com o banco de dados
Postgres, precisamos expor uma porta
e o Postgres
usa nativamente a porta 5432 para
aceitar conexões. Portanto, temos que expor
essa porta
do contêiner usando
o sinalizador Dash P. E agora temos que mapear essa porta Postgres com uma
porta do contêiner. E eu vou escolher um 545
5 v e adicionar dois pontos aqui. Agora, você provavelmente não entendeu do que estou
falando aqui. É por isso que preparei
um diagrama aqui para simplificar a ideia
de expor postagens. Então, aqui temos o Postgres, aplicativo
postgres ou o recipiente de vidro de
saídas. Então, deixe-me mudar o
nome aqui no Postgres. E esse contêiner tem uma
imagem rodando dentro dele. Portanto, essa imagem é
a imagem postgres. E o Postgres
usa nativamente a porta 5432. Mas não podemos conectar
um aplicativo a isso à
imagem Postgres a partir da porta 5432. Quando executamos essa imagem a
partir do contêiner. Porque, como você sabe, os
contêineres são isolados uns dos outros e
do sistema local. Portanto, essa abordagem não funcionará. Portanto, temos que
usar outra forma, que é expor outra placa
do contêiner e mapear do contêiner e mapear essa porta para a porta Postgres ou para a imagem que está
sendo executada dentro desse contêiner. E então, para nos conectarmos
ao banco de dados Postgres, precisamos nos conectar ao host
local cólon 5455. Portanto, temos que nos conectar
ao contêiner, não à imagem em si. Agora, se você tiver
mais de um deles, é claro que pode
conectá-los ao mesmo
contêiner que está executando a imagem postgres. Porque aqui estamos
usando localhost. Mas é claro que não é
recomendável usar o mesmo banco de dados com
outros aplicativos pois você pode perder dados e destruir suas
tabelas de banco de dados, como, por exemplo se o App One está registrando um usuário no banco de dados
com um e-mail a,
então, ao mesmo tempo, também
temos o aplicativo, registrando também um usuário
com o mesmo e-mail. Nesse caso, você
terá, em vez de seu banco de dados, usuários
com o mesmo e-mail, mesmo que tenha validações
em execução em seus aplicativos, que não impede que tal
erro ocorra com B. Então, o que você precisa fazer é criar outro contêiner
com a mesma imagem. Mas desta vez você
precisa nomear esse contêiner com outro nome e
também usar outra porta aqui. Mas é claro que você manterá a mesma porta para
a imagem postgres. Então aqui mudei o nome para, até aqui, o ícone do
Postgres. Portanto, temos a
imagem do Postgres aqui e você precisa alterar essa porta. Caso contrário, você não poderá
se conectar ao contêiner, ou mesmo não poderá
criar esse contêiner porque está
usando a mesma porta em outro contêiner aqui. Então, vou mudar para 5456. E então deixe-me remover isso. O outdo vai se conectar a esse endereço, a esse contêiner. E é assim que você pode ter, como se estivesse criando
um microsserviço, essa é a abordagem certa
para se conectar ao banco de dados. Portanto, seu aplicativo precisa ter seus próprios contêineres que
executem o banco de dados. Agora, eu não sei por que estou rolando para cima e para baixo
repetidamente assim,
mas vamos ignorar isso e voltar aqui dentro nosso terminal e terminar
o contêiner postgres do aplicativo. Então, temos nossas postagens aqui. Agora. Temos que definir algumas variáveis de
ambiente. E é necessário
executar o Postgres ou
conectar-se ao Postgres. Agora, essas
variáveis de ambiente também são definidas aqui. Portanto, temos que definir as mesmas informações,
como nome de usuário, senha, porta, e
alteramos a porta 25455. Agora vamos mudar isso aqui. E a mola,
o terminal aqui, e tente copiar as
mesmas informações. Agora, para adicionar a, uma variável de
ambiente, temos que usar a bandeira
dice e e depois nomear a primeira variável. E a primeira variável
é a treliça Post. E deve estar tudo em letras maiúsculas. Agora, o Postgres sublinha o usuário. Deve ser o mesmo que
o nome de usuário aqui. Então,
será igual a admin. E para definir outra variável de
ambiente, temos que usar novamente
o sinalizador dash g
e, em seguida, escrever a senha do
Postgres. Novamente, tudo em letras maiúsculas. E então a senha é a mesma senha dentro
da fonte de dados do aplicativo. Portanto, a senha é admin e a última
variável de ambiente é o nome do banco de dados. Então, novamente, dicey, depois Postgres. Então, muito grosseiro. Em seguida, sublinhe db para o banco de dados. E o
nome do banco de dados DB é principal. Minúsculas. Deve ter o mesmo
nome apresentado aqui. Obviamente, o nome do host
é host local porque esse contêiner será
executado dentro do nosso sistema local. Agora, vamos executar esse contêiner
e aguardar o resultado. Vamos lá. Temos algum login em
andamento aqui. E essas informações
estão relacionadas ao Postgres. Então, estamos iniciando uma nova
conexão com o banco de dados. E aqui está, temos um sistema
de banco de dados pronto
para aceitar conexões.
25. Teste de ponto de extremidade do Graphql: Agora, para que nosso aplicativo se conecte
ao banco de dados
Postgres, precisamos iniciar a fonte de dados
do aplicativo
dentro do module.js fall. Então, aqui, vamos primeiro
importar a fonte de dados do aplicativo. Fonte de dados. De uma fonte de dados. E dentro deles começa o Apollo
e, desde o início, temos que esperar a inicialização da fonte de
dados. Agora, o
método initialize
se conectará ao banco de dados
Postgres pegará todas as nossas entidades e as
salvará como tabelas de banco de dados. E agora, antes de testar a API, precisamos corrigir algo
e estudar o contexto aqui. Portanto, se tivermos um token JWT
válido, eles verificam
que o método falhará. E quando ele falhar, não
conseguiremos nos conectar
ao endpoint do GraphQL. E não poderemos usar resolvedores que não exijam autenticação porque o
método gerará
um erro e interromperá todo o
nosso aplicativo. Então, o que eu vou
fazer é colocar o método verificado
dentro de um bloco try catch. Dessa forma,
podemos evitar que erros
provenientes do método de verificação sejam lançados para fora
do método de contexto aqui. Então, a primeira coisa que
vou fazer é criar uma variável de
lead aqui. Em seguida, remova a
constante daqui, copie tudo
isso ou cat ou isso e crie o bloco try
catch, catch. Então, aqui, tente detectar o erro. Então, fique aqui, basicamente
carga útil com o método de verificação. E se
falharmos aqui, detectaremos o
erro dentro do bloco de captura. Mas não vamos
lançar o erro aqui
porque, nesse caso, faremos a mesma coisa que eles verificam que o
método estava fazendo. Então, aqui vou definir
a carga útil como não. Agora, se não obtivermos
o token de autorização, eles verificam que
o método
falhará e a carga será definida como Não, Sim. E a propriedade
autorizada será definida como falsa. Portanto, não precisamos da declaração
if aqui. E quando não tivermos
o token de autorização, passaremos
uma string vazia e o método de verificação
falhará de qualquer maneira. Agora, a razão pela qual
estamos fazendo isso e usamos a instrução
if aqui é porque o método de
verificação só aceita strings como um token, não aceita tipos indefinidos
ou nulos aqui. Então, se você não
tinha teorização, vamos passar uma string. Agora, dessa forma, podemos alcançar nossos resolvedores mesmo que não
tenhamos recebido um token. Agora vamos salvar isso
e abrir o terminal. E, finalmente, vamos testar
nosso endpoint GraphQL. Então, aqui, deixe-me expandir isso
e executar npm, run, start. E antes de executar este comando, temos que mudar algo em vez do arquivo adjacente
do mendigo. Portanto, usamos o node
dash, dash swatch aqui, mas esse comando
não observa
as alterações nos
arquivos TypeScript. E precisamos adicionar o relógio de
bandeira assim. Mas neste caso, temos que adicionar apenas um e psi. Porque se usarmos
dois sinais e dois aqui, aguardaremos a execução
desse comando e terminaremos a execução,
e então
executaremos o comando node. Mas o modo relógio aqui
não termina, não,
não tem n. Sim, é por isso
que o
chamamos de modo relógio, Sim. E nesse caso, não executaremos
esse comando. Então, temos que remover isso
e usar apenas um e seno. Nesse caso, executaremos esses dois comandos
ao mesmo tempo. Mas isso é muito perigoso porque imagine se não
tivéssemos a pasta
dist aqui e executássemos o comando
node, node. E nesse caso, comando
denote será interrompido, mas o comando de compilação
que será executado. E ele observará as alterações
na assinatura dos arquivos ts. Mas quando o comando DOS
gera a pasta dist. Descobriremos que
o comando node não funciona e não
observa as mudanças, então ele não saberá disso. Agora temos essa pasta
e, nesse caso, nosso aplicativo
ficará preso no estágio de compilação. Sim. Então, o que quero dizer aqui é que
não podemos usar o comando dash, dash watch aqui. E temos que usar o node man
novamente dentro deste projeto. Portanto, certifique-se de instalar o Node man novamente nas dependências do desenvolvedor. Em seguida, use-o aqui com o comando node sem
a palavra fumado. Então, vamos deletar isso, pegar esse comando
e colocá-lo aqui. Então, vamos excluir isso
e usar o node one. E com a bandeira e e depois ts, eles escondem exatos. Em seguida, vamos executar o comando, o comando de
compilação. Aqui, npm, buy-in,
compile, salve isso. E vamos tentar
iniciar nosso aplicativo. Certo. Agora. Não recebemos nenhum erro
relacionado a um banco de dados, que
significa que
iniciamos com sucesso uma conexão com
o banco de dados Postgres. Agora, vamos prosseguir
e tirar o pó do
endpoint do GraphQL do lado da sandbox do
Apollo, temos aqui um ícone verde
que significa que nos conectamos com sucesso
ao nosso endpoint GraphQL. Agora, vamos tentar inscrever um usuário com as mesmas credenciais aqui e verificar se podemos
salvar usuários no banco de dados. Então, vamos executar essas consultas
de inscrição aqui. E se você não tiver, se
você não tinha isso dos vídeos anteriores, você pode simplesmente voltar à raiz aqui e clicar em mutação escolher a inscrição. Na verdade, vou gerar
a consulta novamente, por precaução. Então, vamos adicionar a
consulta de inscrição ou uma mutação. E os dois campos, o usuário. E aqui vamos apenas
esperar pelo ID para garantir que salvamos
o usuário dentro do banco de dados
com sucesso . Agora, usaremos as
mesmas entradas aqui. E da mutação de inscrição. Tudo bem, temos
aqui o token JWT
e, o mais importante,
temos o ID definido como um. Então, se inscrevermos um novo usuário, precisamos conseguir isso. Temos que ter uma ideia de dois. Então, vamos mudar
o e-mail aqui para usuário dois e o
FirstName user2
e, em seguida, executar a inscrição novamente. E vamos esperar pela resposta. Você tem que obter a identificação dois. E ele iria. Agora, temos certeza de que estamos
salvando usuários e
no banco de dados e
também obtendo resultados do banco de dados. Agora vamos testar o
seletor coreano que pode ser resolvido
porque a mutação senoidal n tem a
mesma lógica da inscrição. Sim, então vamos testar
o usuário coreano. E para isso precisamos enviar
um cabeçalho de autorização. Então, vamos copiar o token JWT. E aqui vamos clicar no ícone Configurações e adicionar
os cabeçalhos de autorização. Então, aqui na teorização, você pode simplesmente começar a
escrever a autorização e
obter algumas sugestões aqui. Escolha autorização
e cole o token. Sim, garante que
o cookie esteja desativado. Caso contrário, não podemos nos conectar
ao nosso endpoint GraphQL. Agora vamos salvar isso. E vamos executar a consulta do usuário em
gradiente. Então, volte para a raiz aqui. Vamos excluir tudo isso, clicar na consulta
e, em
seguida, adicionar a consulta do usuário atual. E vamos esperar pelo e-mail e
pelo ID do usuário
para que não precisemos da entrada. Então, vamos apenas executar a consulta do usuário
atual. E devemos receber o
e-mail e o ID. Vamos lá. Conseguimos que o usuário o fizesse, porque usamos o token JWT
quando nos inscrevemos como usuário2. Agora podemos obter o
e-mail e o ID do usuário. Isso significa que nosso
contexto está funcionando e podemos extrair nossa
carga do token. Agora, no próximo vídeo, vamos criar uma
imagem a partir desse contêiner.
26. de postgres para a imagem: Agora vamos criar uma imagem que executará esse
contêiner para nós. Então, vamos sair
desse contêiner. E então vamos
limpar o terminal. E vamos usar o comando docker commit para
criar uma nova imagem a partir do contêiner
postgres
do aplicativo nomear esse banco de dados de
mensagens de imagem e executar esse comando. E agora vamos tentar
executar essa imagem Docker é executado do que o TI para a direção do
terminal. E então eu mencionei
o nome da imagem. E antes de executar esse comando, temos que expor
também uma porta aqui, porque ao executar uma
imagem usando Docker run, criaremos um
contêiner e a mensagem,
nossa imagem do banco de dados, será
executada dentro desse contêiner. Então, vamos expor as mesmas portas que
expusemos dentro do contêiner postgres do aplicativo usando a bandeira P da mesa na porta
5455 e depois dois pontos, depois a porta do banco de dados
Postgres 5432. Agora, você provavelmente
não entendeu por que estamos usando as
mesmas portas aqui. E isso porque você está
pensando que, quando executarmos a imagem de adição de banco de dados do NSG, vamos realmente executar
o contêiner postgres do aplicativo. Sim, mas esse não é o caso, porque quando
executamos essa imagem, não vamos executar o contêiner postgres do
aplicativo, mas vamos executar
a imagem postgres com todas as variáveis de ambiente
e todas as configurações. Portanto, o
contêiner postgres do aplicativo não tem nada a ver com a imagem do MSG AB DB. E agora, quando
executarmos esse comando, obteremos um
contêiner que executará a imagem postgres também com todas as variáveis de ambiente
e as configurações. Então, espero que agora você possa
entender por que
temos que expor as
mesmas portas novamente. Agora, sempre que
executarmos esse comando, obteremos um contêiner
gerado aleatoriamente. Porque quando saímos
de um contêiner, o contêiner
não é excluído. Mas nós não queremos isso. Queremos que toda vez que
terminarmos de usar um contêiner, esse contêiner tenha
que ser doado. E podemos fazer isso
automaticamente
adicionando um novo sinalizador
ao comando rand, que é o comando RM. E agora podemos executar esse comando. E quando terminamos de trabalhar
com o contêiner, isso significa que quando saímos
do contêiner, o contêiner é excluído
e não obteremos vários contêineres gerados aleatoriamente dentro do nosso repositório Docker. Então, agora vamos executar esse comando e
esperar que a conexão com
o banco de dados seja estabelecida. Tudo bem, temos nosso
banco de dados em execução. Vamos voltar ao nosso
projeto e ao terminal. Vamos executar o npm. Corra, comece. Certifique-se de que você ainda tem
as balas 5455 aqui. Vamos executar o comando. Podemos ver que não
recebemos nenhum erro no banco de dados. Agora eu tenho aqui uma barra dupla
para o endpoint do GraphQL, e isso é porque ela não mudou isso aqui
e diz o arquivo main.js. Então, vou fazer isso agora
e salvar o arquivo main.js. Aguarde a recarga e você terá que
obter o ano correto. Agora, navegue até esse URL. E dentro da
sandbox do Apollo, essa é a API. Então você pode ver
aqui que eu estava testando a validação para o repositório
de inscrição. Portanto, se nos inscrevermos
com o mesmo e-mail, receberemos uma mensagem de erro de solicitação incorreta
informando que o usuário
já existe. Portanto, sabemos que essa parte do
resolvedor de inscrição está funcionando. Agora, vamos nos inscrever como de costume. E aqui, nomeie
user1 e execute a inscrição. E devemos obter um usuário
com um ID definido como um. Certo? Temos o ID e o token JWT.
27. Definindo o quarto Schema: Agora é hora de começar a
trabalhar no serviço de quarto. E, como antes,
vamos começar com o esquema que representa graficamente o arquivo DO. Mas eu não vou escrever
o esquema GraphQL
do serviço de quarto dentro do gráfico esquemático
Gail fail porque, você sabe, é sempre
uma boa prática dividir arquivos
em pequenos pedaços, especialmente se você
tiver um arquivo grande. Então é isso que
vamos fazer aqui. Vamos começar criando uma nova pasta dentro da pasta de
origem e dando um nome a ela. Booms. E então aqui
teremos as salas ou a sala
do GraphQL. E então, aqui
vamos escrever nosso esquema GraphQL
relacionado ao serviço de quarto. E então faremos
a mesma coisa com
o serviço externo. E aprenderemos os arquivos grosseiros
do DO
e, arquivos grosseiros
do DO
e em seguida, adicionaremos tudo
isso automaticamente,
automaticamente dentro do arquivo TO do gráfico de pontos do
esquema. Então, aqui, vamos começar, vamos começar definindo
o tipo de quarto. Então, vamos criar um
tipo e dar um nome a ele. Sala. E
a ROM conterá, é claro, um id do tipo int e é obrigatório e uma matriz de usuários. Portanto, temos que usar o tipo de usuário. E como você pode ver aqui, não
tenho um erro
porque já usamos o tipo de usuário ou declaramos que
eles são do tipo aqui. E como eu disse antes, vamos mesclar
os dois arquivos,
o Earth
Graph Gill e seu próprio GraphQL dentro do esquema,
esse arquivo GraphQL. Portanto, teremos acesso
ao tipo de usuário. Então, aqui vamos definir
a sala com o usuário e as mensagens. Então,
as mensagens serão uma matriz de objetos de mensagem. E temos que
definir isso acima. Aqui. Declare outro tipo,
nomeie-o como mensagem. E sua mensagem terá
um campo de formulário. E é o ID do usuário. Assim, podemos saber quem enviou a mensagem e o
conteúdo das mensagens. E este é do tipo string. Agora, para enviar uma mensagem, precisamos da mensagem em si. Isso significa o conteúdo. E também precisamos do brometo D e depois salvamos
essa mensagem dentro da sala. A mensagem, a
mensagem é matriz. Então, todos os usuários dentro
da matriz do usuário terão acesso
a essa mensagem. Então, se tivermos aqui dois usuários, Usuário
a e Usuário B, a mensagem do usuário
a será recebida para o usuário B. E,
claro, os dois usuários terão acesso
à mesma mensagem. Então, vamos criar uma entrada aqui, digitar e nomeá-la,
enviar entrada de mensagem. E precisamos da mensagem
do tipo string e precisamos do
ID da sala do tipo int. Agora vamos criar a mutação que aceitará essa entrada. Então, aqui digite mutação, a primeira mutação é a mutação da mensagem de
areia. E aqui, assim é MSE,
significa Mensagem. E aqui
aceitaremos uma contribuição. Você pode nomear essa variável como
quiser. Gosto de chamá-lo de entrada. Então, aqui, essa entrada é do
tipo entrada de mensagem enviada. E vamos
devolver a regra. Agora, vamos salvar isso. É claro que não terminamos, mas eu quero criar o arquivo DO
ortográfico aqui. Sim, então vamos criar
um novo arquivo dentro da pasta e
chamá-lo de earth dot GraphQL. E aqui vamos
copiar tudo isso dentro
do esquema GraphQL
e nos certificar de cortá-lo. E então salve esse arquivo e retorne ao autógrafo Gill e cole tudo isso aqui. Agora, não devemos
adicionar o esquema aqui porque isso quebrará nosso endpoint GraphQL
porque vamos
definir isso dentro
do arquivo GraphQL de pontos do esquema automaticamente. Então, vamos removê-lo. E a segurança também
garante que, dentro todo o subgráfico, a eliminação falhe. Temos uma mutação
e uma consulta e garantimos que
ambas estejam em maiúsculas. Portanto, também dentro do
GraphQL errado, há uma mutação. E então criaremos
a consulta e
devemos nomeá-la da mesma forma que fizemos
dentro do Earth GraphQL. E você pode mudar
o nome aqui. Sim, porque não é, não se trata do nome, mas é um local com o mesmo nome. Então você pode ter isso assim. E neste caso
você tem que mudar a notação GraphQL da sala por
um m minúsculo, mas eu não quero isso. Eu quero um M maiúsculo, então vou mudar isso
como antes, e pronto. No próximo vídeo, vamos
escrever a lógica que lidará com a fusão desses dois arquivos dentro do esquema dot
GraphQL automaticamente.
28. Gerar e mesclar esquemas automáticos: Agora vamos criar o arquivo
dentro da pasta de origem e nomeá-lo,
gerar o esquema. No lado Ts, aqui vamos escrever a lógica
que mesclará todos os subgráficos de seus esquemas no arquivo GraphQL de
pontos do esquema. Portanto, a primeira coisa
que precisamos fazer é importar todos os arquivos que terminam com um ponto GraphQL
da pasta de origem. E para isso temos que
instalar um novo pacote. Então abra seu terminal
e execute o comando npm, instale o pacote globe e também instale os
tipos desse pacote. E execute esse comando. Tudo bem, agora vamos fechar o
terminal e voltar aqui. E vamos começar importando
o pacote globo. Então, aqui, globo de brilho. Portanto, globe é na verdade uma
função que podemos chamar e especificar o caminho de nossos arquivos que
queremos pesquisar. Então, para nós, vamos
pesquisar dentro
da pasta de origem e dentro de qualquer pasta e
, em seguida, qualquer arquivo que
termine com GraphQL. E aqui temos que definir um retorno de chamada que
aceitará um erro e arquivos. Então, se
tivermos algum erro, vamos lançar um erro, lançar um novo erro ou lançar
apenas o, vamos continuar. Em primeiro lugar, precisamos excluir o arquivo
GraphQL do esquema existente usando o método unlink
do FS Beckett. Então, a partir dos pacotes do sistema de arquivos. Então, isso é importante. A desvinculação não só de nós, mas de promessas
aqui, farmacêuticos. E temos que esperar por um link e depois excluir
o esquema dot GraphQL. Tudo bem, agora vamos declarar uma variável e
chamá-la de array de tipos. A força
será do tipo array e conterá cadeias de caracteres. Então, ele vai usar todos
os esquemas como cadeias de caracteres. E isso é iniciado em
uma matriz vazia. E aqui, vamos
ler todos os arquivos e colocá-los como cadeias de caracteres
na matriz de tipos. Então, para isso, temos que percorrer os arquivos
usando o método for each. Aqui, pegue cada
arquivo e extraia o esquema do arquivo
usando outro método do pacote
do sistema de arquivos, que é a sincronização de arquivos lidos. Então, vamos
ler, na verdade, um arquivo. E aqui vamos passar
o arquivo aqui. Portanto, esse arquivo é um caminho ou apenas o nome do arquivo aqui é
o caminho do arquivo. E isso é, na verdade
, alterá-lo para o caminho do arquivo aqui. Caminho do arquivo, aqui, caminho do arquivo. E aqui temos que definir
a codificação porque temos que extrair o
esquema como uma string. Então, vamos codificar para um UTF oito e, em seguida, pegar o esquema e
colocá-lo na matriz de tipos. Então, digite array, empurre o esquema. Agora, depois de fazermos isso, temos que criar outra variável e
chamá-la de mortes do tipo. E aqui temos que mesclar
todo o rascunho de seus esquemas. Portanto, todas as cadeias de caracteres dentro da matriz
de tipos em um arquivo. E para isso, precisamos da ferramenta de mesclagem dos pacotes de ferramentas do
GraphQL. Então, vamos até
nosso terminal e estilizar o GraphQL para mendigos NPM. Então, no GraphQL, as ferramentas de
traço e, em seguida, o slush se fundem. Tudo bem, vamos fechar o
terminal e voltar aqui. E vamos primeiro importar a ferramenta de mesclagem
da especificação mais baixa. Portanto, importe, importe desenvolvedores do
tipo nourish do GraphQL. Depois, ferramentas do que produtos. E vamos
usar esse método. Então, vamos copiar o nome
aqui e colá-lo aqui, e depois citá-lo. Vamos passar
na pesquisa de tipo. Agora, esse método vai
gerar uma nota de documento, mas precisamos,
para acrescentar
algo a um arquivo, precisamos gerar uma string. Então, para isso, precisamos de
outra ferramenta do GraphQL. Portanto, importe do GraphQL
outro método chamado print. Portanto, a frente pegará o typedef superior e será
convertido em uma string. Então, digamos aqui, isso coloca isso
dentro dos métodos da planta. Agora, o tipo, isso
é do tipo string. Então, vamos acrescentar
a string dentro do arquivo
GraphQL de pontos
do esquema usando o método append
da bagagem FS. Portanto, certifique-se de importar o aqui. E agora vamos usá-lo e mencionamos o
esquema dot GraphQL. E aqui temos que
adicionar os tipos que podemos
anexá-los ao arquivo
gráfico esquemático Gil. E essa função também
aceita um retorno de chamada. Então, vamos definir a função
e aceitaremos um erro. E então, se
tivermos algum erro, vamos
resolver isso melhor. Tudo bem, agora, se terminarmos, quero ver uma mensagem de confirmação
no meu site, meu terminal. Então, vou registrar
no console a mensagem
gerada pelo esquema GraphQL. Ou talvez vamos usar
as informações de pontos do console. E antes de acrescentar
ao esquema, esse arquivo GraphQL, temos que
criar esse arquivo
porque aqui estamos. Vamos excluir a eliminação
do schema.gov. Portanto, para criar um arquivo, precisamos usar o método
correto de sincronização
de arquivos dos pacotes FS. E, novamente,
certifique-se de importar isso do pacote FSLR. Aqui também adicionaremos
o esquema dot GraphQL. Portanto, esse é um caminho para
a culpa do gráfico de esquema. E ao mencionar
apenas o nome, estamos transformando esse método de
que o gráfico de esquema Gill realmente existe dentro
da raiz desse projeto. Então, aqui, gráfico de esquema. E eu quero
acrescentar a esse arquivo uma mensagem dizendo que esse
é um esquema gerado. Então aqui, digamos que não. Certo? Agora, vamos
também uma nova linha. E aqui precisamos adicionar uma bandeira em um objeto e
dentro dessa opção semelhante a div. E como vamos
acrescentar algo a esse arquivo, vamos usar o
sinalizador a para anexar. E também porque estamos excluindo o esquema
GF q five aqui, temos que usar o sinal de adição para criar o arquivo,
caso ele não exista. Agora, deixe-me ajustar o código aqui. E vamos também adicionar
outra linha aqui. Barra invertida n para uma nova linha. Agora terminamos de criar esse script e
vamos executar
a função globe como um comando do arquivo
package.json. Temos que fazer isso antes de
gerar a força dos tipos
para nosso esquema GraphQL. Então, antes desse comando, vamos executar
note e, em seguida, nos referir
à pasta dist e ao esquema de
geração de origem que Z, S. E aqui no comando de compilação, vamos compilar nosso código
e, em seguida, vamos
executar o comando degenerado. Então aqui, npm, run generate
two e science também aqui. E depois salve. Agora, vamos abrir o terminal
e executar o degenerate come out. E, claro, precisamos
compilar o código primeiro. Então, vamos executar o TSE. E então vamos executar
o npm run generate. E aqui está, temos a mensagem
gerada pelo esquema GraphQL. E agora temos que analisar a garota gráfica
do esquema e adicionar todos esses tipos de
TypeScript gerados lá. Agora vamos verificar o
esquema desse equipamento de golfe. E aqui vamos nós. Temos nosso esquema gerado. Temos nossos tipos e insumos. E aqui a mutação, você pode ver que
temos as mutações desativadas, a inscrição e o login. E temos a mutação, a mutação de envio de mensagem, adicionada
automaticamente
ao tipo de mutação. E, claro,
temos apenas uma consulta, a consulta atual do usuário. E você também pode ver aqui que temos o esquema também
gerado aqui automaticamente. Sim. E lembre-se de quando eu disse que teríamos
acesso ao usuário aqui, se você não entendeu isso. Quero dizer que quando gerarmos
o esquema, o esquema, o GraphQL,
teremos todos os tipos em um arquivo. Então, vamos ter acesso
também ao tipo de usuário. Sim. Portanto, não há problema em usar os tipos de usuário dentro do arquivo
room dot GraphQL, mesmo que não tenhamos
declarado isso aqui. Agora, no próximo vídeo, vamos criar
os resolvedores de sala. E então, dentro do
módulo, o arquivo ts, vamos
mesclá-lo com os resolvedores.
29. criando o resolver de sala: Agora, dentro da pasta rooms, vamos criar um novo
arquivo e nomeá-lo a partir desse ponto do resolvedor,
vamos exportar uma constante com
um nome, resolvedores de sala. E essa constante será
um objeto do tipo. Aparência do resultado. É importante que, a partir de
nossos tipos gerados. Portanto, uma porta de resolvedores
de sai Quando nivelar e selecione essas pastas
integradas e, em seguida, selecione os resolvedores. O arquivo de tipos de traço
agora está aqui. Vamos
definir a mutação. E só temos uma mutação, que é a mutação de envio de
mensagem. Agora, como não
criamos a entidade, enviaremos
de volta dados criados manualmente. Aqui, vamos definir primeiro
a estação de mensagens de areia. E nós temos o pai, temos a entrada e o contexto. Tudo bem? Agora, somente
usuários autorizados podem definir a mensagem. Então, vamos verificar se temos um usuário autorizado
verificando os contextos que
autorizaram a propriedade. E então, se tivermos força aqui, lançaremos um novo erro do GraphQL e nos certificaremos de
importá-lo do GraphQL. E então vou enviar de volta um método
não autorizado
ou eu mandar uma mensagem. Então, uma mensagem autorizada, e isso é uma extensão. Então, aqui estão as tensões. E vamos enviar o casaco
não autorizado aqui. E para aumentar. E agora vamos
devolver um objeto da sala. Então, deixe-me verificar
a aparência do objeto. Então, temos um ID, mensagens de
usuários. Então, vamos adicionar isso. Todo esse retorno é um. E para os usuários, temos que criar uma
matriz de objetos de usuários, mas podemos simplesmente enviar de
volta uma matriz vazia e também a matriz de mensagens. Mas isso é um saco de areia, só uma mensagem aqui. Deixe-me verificar a aparência da
mensagem. Temos
campos de origem e conteúdo de um objeto de,
digamos, um e da mensagem de teste de
conteúdo. Tudo bem, agora vamos salvar
esse arquivo de resolução. Ou, na verdade, vamos
usar a entrada do objeto da mensagem apenas para garantir que possamos
ser os dados do cliente. Para o conteúdo,
vou retornar
a mensagem de ponto de entrada. E aqui temos a mensagem, seja uma string ou indefinida porque não adicionamos um ponto de
exclamação aqui. Então, vamos fazer isso. Salvar. É claro que precisamos
gerar o esquema novamente. Então, vamos executar o NPM, gerar o npm, entrar, certo? Tudo bem, agora geramos
o esquema e os tipos. Então, vamos voltar aos
servidores normais e podemos ver que
o erro desapareceu. Podemos remover o ponto de
interrogação daqui. E a mensagem agora é
apenas do tipo string. E aqui dentro do ID, vamos enviar de volta
a entrada do ID da sala. Porque este é um quarto perturbado. Sim, vamos salvar isso. E no próximo vídeo
vamos nos fundir. O autor acabou e
a sala se resolve aqui dentro do arquivo
module.js e depois endpoint do GraphQL.
30. mesclar resolvers: Agora, para
mesclar os resolvedores, precisamos de outra ferramenta
do GraphQL para cortar pacotes de
mesclagem. Então, no topo desse arquivo, vamos importar a nova ferramenta, nutrish resolvers do GraphQL, ferramentas de
painel que cheiram ao pacote. E também precisamos
importar o resolvedor da sala. Então, aqui, resolvedores de regras da pasta rooms e
do arquivo Room Resolvers. Tudo bem, agora,
na parte inferior,
vamos usar
a
função ou ferramenta de resolvedores de mesclagem dentro
da classe do módulo app. Então, deixe-me cortar isso e usar os resolvedores de mesclagem
como uma função. E essa função aceita
uma série de resultados. Então, vou adicionar uma matriz e colar o escritório do
autor aqui. E você pode ver que o
erro desapareceu porque os resolvedores do comerciante
retornarão o tipo de resolvedor. E aqui podemos
adicionar muitos resolvedores o quanto quisermos, porque
estamos aceitando uma matriz. Então, vamos também adicionar os
resolvedores de sala e salvar esse arquivo. Agora, vamos verificar se ainda
podemos executar nosso PI e se
não quebramos nada. Então, vamos abrir o terminal e
executar o comando npm start. Primeiro. Vamos nos certificar de que
temos um banco de dados em execução. Então, usando o Docker, essa é uma delas. Em seguida, esse traço ou M para remover o contêiner quando
terminarmos de trabalhar com ele, depois TI para terminal
e direção e, em seguida, nomeie nossa mensagem como imagem DB. E não se esqueça de expor
a porta 5455 e a 5432. E vamos executar esse comando. Certo. Agora. Vamos voltar aqui
e executar o npm start. Esse comando
gerará primeiro
o esquema
e depois gerará os tipos e depois um, a API. Mas primeiro,
vamos compilar o código e depois executar
o comando incinerate
e, em seguida, executar nossa API. Temos aqui o
esquema GraphQL gerado. Também temos os tipos. E agora devemos receber
a mensagem de sucesso. Agora, vamos abrir a caixa de areia. Sandbox e vamos primeiro nos inscrever. Então aqui eu tenho a mutação
de inscrição, eu tenho todas as entradas. Vamos tentar nos inscrever. Como você pode ver aqui,
temos o ID. E isso porque toda
vez que fecharmos o banco de dados e o executarmos novamente, obteremos um novo banco de dados. Sim. Então, vamos pegar agora o
token JWT , acessar as configurações e adicionar o cabeçalho de
autorização lá. Aqui, a autorização ou
o token JWT, salve. E agora vamos executar a mutação da mensagem
enviada. Deixe-me esclarecer tudo isso. E vamos voltar
à mutação. E uma mensagem de areia, ou mesmo a predação do envio de
mensagens. Os resultados são os campos. Aqui. Não temos usuários, mas vamos adicionar o ID lá. E vamos obter a partir da mensagem
e do conteúdo. Agora, para a entrada, vamos limpar tudo isso primeiro e depois adicionar a
mensagem e o ID da sala. Então, a mensagem aqui,
essa é a mensagem. E a identificação do quarto.
Digamos: Bem, claro que não temos tabela de
identificação de sala, defina o banco de dados. Então, vamos enviar uma mensagem. E devemos voltar. E o objeto do ID da sala com
id1 usa uma matriz vazia. E temos aqui
nossa mensagem com a mensagem de teste de
mensagem diretamente aqui. Agora, tudo está funcionando. Ainda precisamos criar a entidade
da sala e finalizar
os resolvedores da sala.
31. criando a entidade de sala: Agora vamos criar
a entidade da sala. Então, dentro da pasta rooms, crie outra pasta
e chame-a de regra. E então, aqui, crie outra pasta
e nomeie-a como entidade. E então, finalmente, vamos criar a entidade de pontos da sala que sim. Então, vamos começar por Exportar e definir uma classe
com o nome Roma. Em seguida, temos que usar a entidade, o caractere da fita ao redor, a entidade de
suporte do tipo ou N e usá-la para essa classe. Agora, aqui dentro,
começaremos com o ID. E, novamente, temos que importar a coluna primária gerada, o caractere do ID. E aqui é estranho
que o personagem,
então, precisemos de uma variedade de usuários. Então, aqui vamos adicionar usuários e defini-los como uma matriz de usuários. E temos que importar a entidade
do usuário do usuário, essa entidade dot ds. Então, aqui, o usuário
volta um nível, dois níveis e três níveis. Lado A pasta de usuário desativada e
triste. Selecione o interior
da pasta da entidade. Selecione o usuário,
esse arquivo de entidade. Agora, os usuários são
uma coluna, então precisamos importar uma cor e o caractere
do texto ao redor. Então aqui, Carlin, e use-o aqui. Agora, para a coluna de usuários, vamos criar uma relação de muitos para muitos
com a entidade do usuário. E para isso temos que
importar muitos para muitos, o personagem de uma
fita e usá-lo aqui em muitos, muitos. Agora temos que definir o
tipo da relação
e, no nosso caso, é a entidade do usuário. Então, aqui temos que
adicionar uma função e encontrar ou retornar a entidade
do usuário como um tipo. Agora, para que isso funcione, temos que adicionar
outro caractere,
a tabela de junção, à
Garreta e usá-la aqui. Então, na tabela de junção, o personagem pegará os IDs da sala e entidades
do usuário e os
salvará em uma tabela. Agora, só precisamos usar
a relação de muitos para muitos em
um lado da relação. E isso é chamado de relação
unidirecional. Se você quiser criar um relacionamento
bidirecional, você pode ir até a entidade do usuário. E aqui você pode
criar outra coluna e chamá-la de regra, e usar
o personagem de muitos para muitos. Agora, aqui temos
a entidade da sala. E isso deve ser uma matriz. E use os muitos para muitos
para caracterizar aqui e definir o tipo. Então, aqui vamos
pegar a entidade da sala. E também aqui precisamos
adicionar outra função na qual temos que retornar a propriedade que possui o
outro lado da relação. Então, no nosso caso, além do objeto da sala, vamos obter
o outro lado
da relação da propriedade
do usuário. E devemos fazer a mesma
coisa dentro da entidade da sala. Mas para a
tabela de junção, o caractere, devemos usá-lo apenas em um
lado da relação aqui. Então, aqui, vamos fazer a mesma
coisa, apenas um exemplo. Então, aqui o usuário
e, em seguida,
retornam o usuário dot room, porque a propriedade da sala possui o outro lado
da relação. E deveria, deveria ser
quartos, não um quarto aqui. Mas, novamente, é só um exemplo. Sim, não vamos usar
a relação bidirecional aqui. Só precisaremos
da relação sindical, das relações
unidirecionais. Então, vamos estudar isso e salvá-lo, retornar à entidade do usuário
e remover tudo isso. E certifique-se de excluir
todas as instruções de entrada da entidade da
regra e fechá-la. Agora ainda não
terminamos porque o banco de dados Postgres
não suporta matrizes. Sim. E para isso, precisamos usar um tipo muito
exclusivo de JSON, que é o JSON B. Agora, os tipos de dados Jason e Jason B são quase idênticos. A principal diferença
é que os dados JSON são armazenados como uma cópia exata
do texto de entrada do json. O que é JSONB armazena
dados em um decompositor. O binário para isso
não é como uma string. Sim, como JSON, mas
como um código binário. E é isso que o
binário significa. Nosso ADB significa, significa um binário. Agora, essa é a
única maneira de trabalhar com matrizes com o Postgres. Então, temos que fazer isso. Você precisa usar JSON v em
vez de matrizes simples
serem apenas JSON simples. Agora vou adicionar uma
opção aqui e dizer anulável, falso porque não
quero obter um valor nulo aqui para
a propriedade do usuário. Tudo bem. Agora ainda
precisamos das mensagens. Então, vamos adicioná-lo aqui. E
será do tipo mensagem. E podemos importar isso
dos tipos gerados. Certifique-se de mudar isso. Saia de dois níveis, pense em três níveis. E aqui, vamos
fazer disso uma matriz. Se você passar o mouse sobre esse tipo, verá que
temos o conteúdo e o formulário como propriedades
obrigatórias. E temos aqui o nome do tipo, que não é obrigatório. Portanto, podemos usar
o tipo de mensagem aqui. Sim, não é o problema. Agora. Aqui, vamos definir uma coluna. Uma coluna. E temos que usar o início adjacente porque não
podemos usar o apagamento simples. E eu quero que não
seja anulável. Então, vou adicionar
anulável igual a falso. E seguro.
32. criando e atualizando salas: Agora, dentro da pasta da sala, vamos criar outro
arquivo e
chamá-lo de room dot service que sim. Aqui vamos exportar um serviço de sala de
aula e, assim, criar o construtor. E aqui vamos criar
a sala, nosso repositório. E será do
tipo repositório. Podemos importar isso
de uma fita adesiva. Portanto, importe o repositório
do type around. Aqui, precisamos adicionar
a entidade da sala
como argumento aqui, Roma. E isso é importante
para a entidade. Agora vamos definir o método que criará uma sala para nós. Então, aqui, atuando, crie espaço. E esse método aceitará
um argumento dos participantes, que é uma matriz de usuários. Então, aqui, usuário da matriz, e essa é a entidade do usuário. Portanto, precisamos
importá-lo daqui, portar
o usuário de dois níveis e
selecionar a pasta oath. E a partir daí, a pasta do usuário, a entidade e o arquivo da entidade
do usuário, não apenas os participantes aqui, também
precisamos da mensagem. Porque quando
vamos criar uma sala, quando o usuário tenta enviar uma mensagem para outro
usuário pela primeira vez. Então, aqui a mensagem será do tipo mensagem. E, novamente, vamos importar isso desses tipos gerados. Então, aqui, importe a mensagem de fora
para um nível, dois níveis. E, em seguida, pasta
gerada no sábado, selecione o arquivo de tipos de resolvedores. Agora, aqui vamos
criar uma sala com o repositório do repositório e
onde eles criam métodos. Agora é verdade, exceto os usuários. Portanto, os usuários ou
os participantes também
aceitam
a matriz de mensagens. Então, como vamos
criar uma nova sala, vamos adicionar a mensagem
manualmente em uma matriz. Então, vamos obter uma
matriz com uma mensagem. Tudo bem, agora temos que
devolver um peso, esse repositório da sala de pontos que salva e passa o documento da sala. Agora parece que
eles têm um erro de digitação aqui no repositório. Então, deixe-me corrigir isso. E eu vou usar a seleção múltipla e mudar isso
para talvez um repositório, certo? Agora vamos economizar. E agora temos que lidar com
o caso em que temos, em que queremos enviar uma
mensagem para uma regra específica. Então, aqui vamos criar
outro método. Será assíncrono novamente e escolherá o nome adicionará mensagens para rolar. Você pode escolher o nome da mensagem de
areia. Mas quero deixar bem claro que vamos
enviar uma mensagem para uma sala, e aqui vamos
criar uma sala. Sim. Agora, para fazer isso, para enviar uma mensagem
para uma sala específica, precisamos do ID da sala, é
claro, do tipo número. E precisamos da mensagem
do tipo, mensagem. Aqui, mensagem. E agora está aqui. Vamos usar
o Query Builder. E isso é porque temos que
lidar com Jason em matrizes. Então, se você se lembra, definimos a
coluna de mensagens como JSON B. E, como temos aqui,
o sinal de matriz do TypeScript será
do tipo Jason be array. Portanto, a única maneira de
lidar com as matrizes de Jason é usando
a consulta criada. Agora vamos definir o
Query Builder aqui. Esse ponto é positivamente
nosso próprio repositório. Crie o Query Builder. E aqui vamos criar um construtor de consultas de peso. Atualizar. Ou seja, vamos atualizar uma sala existente e seguida, adicionar a nova mensagem
à matriz de mensagens. Portanto, atualize, precisamos da entidade da
sala aqui como tipo e propriedade que
será atualizada dentro de um objeto. Então, vamos atualizar
as mensagens e usar forma
muito específica e exclusiva de
atualizar essa propriedade. Então, vamos
usar um método ou uma função para retornar uma consulta. Nesta consulta terá o nome da propriedade das mensagens
e, em seguida, adicionará 2 barras aqui. E eu vou explicar
isso em apenas um segundo. Sim. E agora vamos adicionar
aspas. E aqui dentro vamos
adicionar as mensagens
como uma string JSON. Então, vamos usar o método stringify
JSON e passar a mensagem. E então lembre-se de que precisamos adicionar mensagens
à medida que Jason venceu. Então, vamos
converter isso para Jason V adicionando duas colunas. E então, certo,
Jason, seja assim. Portanto, toda essa string
é uma consulta Postgres. E quando adicionamos as duas
colunas, o Jason fica
assim , vai ser analisado
pelo Postgres como uma consulta. E o Postgres cuidará da
conversão dessa string, dessa string JSON,
duas batidas adjacentes. E a barra 2 aqui significa
que vamos
acrescentar essa string JSON B e
à propriedade messages. Agora, usando o
Construtor de consultas para adicionar uma consulta com
o método de atualização, precisamos retorná-la
como um método de um método. Ok, agora, deixe-me ajustar esse código e continuar
com o Query Builder. Então, vamos atualizar uma sala, mas temos que identificar a sala que
vamos atualizar. E para isso,
usaremos o método Where. E esse método adicionará
uma condição where ao uma condição where construtor
de consultas e
criará a condição where. Vamos adicionar uma string aqui
e dizer que vamos
atualizar uma sala em que o
ID é igual ao ID da variável, e podemos definir essa variável em outro
argumento desse método. E dentro de um objeto, defina o ID e ele será
definido como o ID da sala. Agora, ainda precisamos executar essa consulta usando
o método execute. E se você passar o mouse sobre ele, verá que esse
método
retornará resultados de um banco de dados de linhas, mas precisamos
retornar um tipo de sala. Portanto, esse método de execução de
consulta não funcionará com
um ambiente TypeScript. Portanto, vou
retornar um peso e
pesquisar o documento atualizado. Então, há o repositório da sala e, em seguida, use o método
find one. E vou
procurar um quarto com ou onde o id seja igual
ao ID do quarto. E também para
retornar as relações, temos que adicionar a propriedade de
relações e especificar uma matriz ou uma matriz das relações que
queremos buscar. No nosso caso,
temos apenas uma relação, que é a matriz do usuário. E é isso. É assim que podemos atualizar
uma entidade e devolvê-la
com o Query Builder.
33. CreateRoom resolver 1/2: Agora, antes de começarmos a
usar o serviço de sala, precisamos importar
a fonte
de dados do aplicativo criar uma instância aqui e passar o repositório da
sala. Então, vamos primeiro importar a fonte
de dados do aplicativo de dois níveis e depois
selecionar a fonte de dados. Agora, aqui, temos que exportar uma constante e
chamá-la de serviço de quarto e criar uma nova instância
do serviço de quarto. E passe ou use a fonte de
dados do aplicativo e, em seguida,
pontilhe o repositório Git e
passe a entidade da sala. E aqui altere isso para exportar. Tudo bem, vamos salvar
isso e fechá-lo. Volte ou abra as salas
dos resolvedores e importe o serviço
de quarto do arquivo do serviço de quarto. E aqui vamos definir a mensagem
ou enviar o resolvedor de mensagens. Vamos excluir a declaração de
devolução. E vamos
devolver o peso. Os quartos
atendem essa mensagem para Roma e passam o ID do quarto
primeiro desde a entrada até o meu d. E depois precisamos
passar a mensagem. E a mensagem é um objeto
com conteúdo de propriedade. E
obteremos o conteúdo inserindo essa mensagem. E também temos que
adicionar a propriedade from, que é o ID do remetente, que no nosso caso é
o ID do usuário atual. E podemos obter
isso do contexto, desse usuário coreano, desse id de usuário. Agora terminamos com o resolvedor de mensagens de
areia. Agora, aqui, vamos adicionar
uma vírgula e, em seguida, criar o resolvedor da sala de criação. Então Async, crie espaço e depois para o pai. Então, aqui, crie uma sala e
eu criaria um pai e, em seguida, adicionaria a entrada e o
contexto, o contexto. Certo? Então, aqui
temos a sala de criação, mas estamos recebendo esses erros
porque não definimos o criador da mutação dentro do esquema GraphQL da
nossa sala. Então, vamos fazer isso bem rápido. Aqui. Vamos criar outra
mutação e dar um nome a ela. Crie espaço. E entrada do tipo. Crie espaço, insira. E vamos definir isso aqui. Entrada, crie entrada de sala. Então, eu tenho aqui o preenchimento automático. Muito irritante. Vamos corrigir isso. E, em vez disso, eles
criam espaço no livro. Vamos aceitar
um campo de mensagem com uma sequência de caracteres e um receptor. Os caras do tipo int
receberão a identificação do receptor. Agora, aqui temos que retornar
o tipo de devolução. Então, vou retornar
a linha e depois salvar. Volte para o resolvedor da sala. E para isso, precisamos gerar o esquema ou os tipos
do esquema GraphQL. Então abra seu terminal e
execute npm, execute generate. No momento, acho que
esquecemos de adicionar. Uma coisa muito importante é
que nosso esquema aqui é tornar necessária a entrada de criação da
sala. Caso contrário, você receberá erros de
TypeScript ao tentar usar
a entrada de criação de ROM. Então, aqui, vamos executar esse comando novamente e limpar isso ou
simplesmente remover o terminal. Volte aqui. Agora, a primeira coisa que precisamos é
autenticar o usuário. Então, vou copiar tudo
isso e colar aqui. Agora, temos que verificar
se já temos uma sala que contém o
receptor e o remetente. E para isso, temos que criar outro método dentro
do serviço de quarto. Então, vamos abrir o
serviço de quarto e, aqui, criar outra
função assíncrona e chamá-la de
find, boom, com o ID de um usuário. Tudo bem, agora vamos pegar ou procurar um usuário para um
quarto com o ID do destinatário, o número do
tipo e também o
ID do remetente do tipo número. E aqui vamos usar o Query Builder para
buscar as relações dos usuários. Então, vamos criar uma constante aqui e chamá-la de Construtor de consultas. Em seguida, use o repositório da sala para criar uma nova consulta com eles. Vamos adicionar um alias
aqui para se referir à entidade
da sala da
tabela da sala dentro de um banco de dados e criar uma constante de salas
porque vamos buscar todas as salas que contêm um usuário com o ID do remetente do
ID. Então, vamos fazer isso. Aguarde o criador de consultas. Em outra linha, vamos selecionar tudo e usar o método de junção interna para unir toda a relação dentro da propriedade room dot
users. Então, aqui vamos descobrir
que os usuários,
em seguida, adicionaremos
um alias para se referir à relação
dos usuários. E eu vou escolher
simplesmente a letra U aqui. E então vamos adicionar uma condição
onde a condição
satisfaz a condição. Vamos mapear a matriz de relações do usuário. E isso é adicionando
aspas duplas como esta. Você aureus e, em seguida, adiciona outras
aspas duplas com um ponto aqui para selecionar o ID. Em seguida, verifique se o ID é igual ao ID do remetente
variável. E aqui podemos definir
esse ID de remetente variável. E então vamos
usar os métodos get many para conseguir muitos quartos. E então vamos usar JavaScript
para retornar um booleano aqui, retornar e adicionar pontos de
exclamação duplos aqui. Em seguida, salas em um ponto de interrogação
porque podemos obter nulos. Então sum é o método de soma
para verificar se alguns quartos
têm uma condição muito específica
que é arredondada para usuários. Então, vamos verificar
se é um dos quartos. E dentro da propriedade desses usuários, podemos encontrar pelo menos um usuário que tenha um AD
igual ao AD do receptor. Tudo bem, agora temos
aqui alguns métodos, mas é homossexual. E agora podemos evitar a criação de várias salas
para os mesmos usuários.
34. CreateRoom resolver 2/2: Agora, se tivermos uma sala dois usuários com o ID do
receptor e o ID central, não
criaremos
uma nova sala para eles. Então, vamos criar uma constante
aqui e dar um nome a ela. O quarto tem usuários. Em seguida, use o serviço de quarto que encontra uma sala com ID de
usuário ou ID de usuário. E então temos que passar
o ID do receptor da entrada desse receptor e o ID do remetente dos contextos daquele usuário coreano, esse ID de usuário. Tudo bem, agora vamos verificar. Se tivermos uma sala
com usuários
, voltaremos ao YouGov KL e diremos que receptor já existe ou que
apenas o espaço já existe. Sim. Então aqui o quarto já existe. E é isso. Agora, se não
encontrarmos uma sala onde o
destinatário e o remetente, enviaremos ou criaremos a sala e depois
enviaremos a mensagem. Então, vamos retornar 08, o serviço de quarto
que cria fila. Agora, esse método aceita a matriz de
um participante, que é uma matriz de usuário. Portanto, temos que buscar usuários
do repositório de usuários. E para isso,
vamos criar outro método dentro
do serviço de usuário que retornará vários
usuários por seus IDs. Então, vamos criar um método assíncrono
e chamá-lo de find by ID. Porque vamos
passar uma série de ideias, chamaremos There's
find by ID in array. E aqui em ideias, argumentos do tipo,
matriz de números. E retorne. Espere que o ponto
do repositório do usuário localizado por ID que existe
dentro da matriz do ID. E para isso, vamos
usar um método do tipo de RAM chamado no método. Portanto, certifique-se de
importá-lo primeiro do tipo ramp e depois da matriz do ID. E o método encontrará todos os usuários que têm IDs
que existem dentro da matriz. Portanto, podemos nomear esse
método de find por IDs em vez de find
by ID na matriz. Tudo bem, agora vamos
salvar o serviço do usuário, fechá-lo e voltar aqui. E vamos criar
um participante, uma pesquisa. Participantes. E vou usar
o serviço de usuário. Primeiro, isso é importado
da pasta externa e
do arquivo de serviço do usuário. E aqui, aguarde o
atendimento ao usuário que encontre por ID. E vamos passar uma matriz com dois IDs dos
contextos que currentUser. Vou pegar o ID do usuário. Da entrada. Vamos pegar
o ID do receptor. Sim, então aqui, vamos passar os participantes
e a mensagem. Portanto, a mensagem tem
duas propriedades. O primeiro é o conteúdo. Pode obter isso
inserindo essa mensagem e a propriedade from que representa o receptor
ou o ID da matriz central. E podemos obter isso do ID de
usuário do ponto CurrentUser. E isso é tudo para
criar um resolvedor de sala.
35. Criando um resolver no getRooms: Agora vamos
criar uma consulta que
buscará todas as salas do banco
de dados. Então, vamos começar
da sala desse esquema do GraphQL e
definir uma nova consulta. E dê um nome a essa consulta, obtenha quartos. E não
aceitará nenhuma entrada, mas retornará
uma matriz de objetos. Vamos salvar esse esquema do GraphQL
e gerar os tipos para os resolvedores usando o comando
NPM run generate. Tudo bem, feche o
terminal na sala, aquele arquivo GraphQL e depois
volte para os resolvedores da sala. E aqui, sob a mutação, vou definir uma consulta. Em seguida, defina o resolvedor get
Rome. E obteremos uma
entrada principal e vazia e o contexto. E aqui temos que
autenticar o usuário. Então, vamos copiar isso
e colar aqui. Agora precisamos criar
um novo método dentro
do serviço de quarto que
busque todos os quartos para nós. Então, no topo, crie um novo método assíncrono
e nomeie-o, obtenha todos os grupos. E vamos conseguir todos os
quartos para um usuário específico. Então, aqui aceitaremos um ID de
usuário do tipo número. E vamos usar o Query Builder para buscar as relações
dos usuários
e,
em seguida, retornar todas as salas que têm um
usuário com esse ID de usuário. Então, vamos primeiro definir o construtor de consultas
a partir do repositório da sala. Crie o Query Builder e
escolha uma sala de aliases. E então aqui vamos
usar o Editor de Consultas. Então, vou retornar
08 Query Builder. E então vamos juntar as tabelas de usuários dentro da sala que os usuários
possuem da mesa da sala. Então, aqui está a junção interna, junte as tabelas de relações
e selecione usuários arredondados. E vamos nos referir
à matriz de usuários
com a letra U. E aqui vamos
usar a palavra condição. E vamos selecionar
todas as salas que têm um usuário com um ID
igual ao ID variável. Podemos definir o ID da
variável aqui, SAT, esse ID de objeto
é igual ao ID do usuário. E então teremos
muitos, muitos quartos. Então, vamos
usar isso, pegar muitos. Agora mesmo. Vamos
salvar isso e voltar para os resolvedores de sala
dentro da consulta get room. Vamos devolver um peso. serviço de quarto obtém todas as rotas e passa
o ID do usuário dos contextos, currentUser e, em seguida, o ID do usuário.
36. Teste o graphql: Agora é hora de testar nossas APIs. Portanto, certifique-se de ter o banco de dados
Postgres em execução. E você pode fazer isso
usando esse comando. Certifique-se de expor
as portas corretas. E então venha aqui e execute o npm. Começa a correr. Tudo bem, agora vamos navegar
até uma caixa de areia de polo. Certifique-se de se
inscrever e copiar o
token JWT dentro das configurações de
conexão e dentro do cabeçalho de
autorização. Agora, mutação silenciosa,
vamos testar a mutação de envio de mensagem. Mas primeiro precisamos criar outro usuário
para enviar uma mensagem para. Sim, vamos aqui. Reenvie a
mutação de inscrição com o usuário para o e-mail e
o nome e execute a inscrição. Agora, desta vez, não
vamos
copiar esse token JWT dentro
do cabeçalho de autorização porque precisamos
nos autenticar como o primeiro usuário
ou um desses usuários. Sim. Então, aqui temos o usuário com id2
e vamos
enviar uma mensagem para ele
com o, com seu AD. Então, isso está claro. Isso remove a
mutação de inscrição e remove a entrada. Clique em Enviar mensagem. E a mutação de envio de mensagem. Vamos receber os usuários de identificação e as mensagens da sala. Então eu disse os usuários. Vamos pegar o primeiro, o
primeiro nome e o ID. E então, para as mensagens, isso se encaixa no campo do formulário ou do
campo de destino e, em seguida, no conteúdo. Tudo bem, agora, para as entradas, temos que adicionar a
mensagem e o ID da sala. Mas
ainda não temos salas em nosso banco de dados. Então, o que precisamos
fazer é
criar uma sala antes de
enviar a mensagem. Então, vamos adicionar a criação
por meio de mutação e adicionar. Deixe-me esclarecer tudo isso primeiro. E então adicionamos a sala de
criação ou a, todos os campos aqui. E para os usuários, você receberá o id
e o nome, as mensagens das quais
os obteremos. Não nos importamos com tudo
isso apenas por mensagem. Mesmo aqui, vamos enviar
uma mensagem para um usuário. Sim. Deixe-me verificar quais
campos temos ao lado, as mensagens têm conteúdo. Agora vamos voltar.
E as entradas. Deixe-me apagar toda essa
mensagem e adicionar o receptor. O receptor será usado com id2 e
a mensagem com a mesma forma de
texto simples, como mensagem de texto. Agora vamos enviar ou criar a
sala e enviar a mensagem. Tudo bem, temos aqui o objeto da
sala com ID 1. E temos uma variedade de usuários. Sim, e temos o
ID do usuário. Sim, FirstName é um e o segundo usuário
dentro desta sala. Então, esses dois usuários agora
podem enviar mensagens um para o outro. Temos aqui a
matriz de mensagens com apenas uma mensagem. E essa mensagem foi
enviada pelo usuário com ID1. Então, o usuário. Agora, se tentarmos
criar outra sala com
o mesmo ID do receptor, receberemos um erro dizendo
que essa sala já existe. Então, vamos ver se funciona. Tudo bem, então aqui temos
a sala de mensagens que já existe e estamos seguros. Então, a próxima mutação que
vamos testar é a mensagem de areia. Então, deixe-me limpar toda essa entrada e adicionar a mutação de
envio de mensagem. Vamos ter uma ideia
da sala, do ID do usuário e do primeiro nome do usuário. E então vamos receber
também as mensagens aqui. Vou pegar o
campo de origem, o campo de conteúdo. E então, para as entradas, temos que adicionar uma entrada de mensagem, ou
seja, minha entrada D vai
enviar uma mensagem para a sala, ID um. E vamos adicionar uma mensagem, outra mensagem de teste e enviar uma mensagem. E aqui vamos nós.
Temos a mesma sala, um documento da sala com
os mesmos usuários. E aqui adicionamos outra mensagem
à matriz de mensagens. E o usuário2 também pode enviar
mensagens para esta sala, mas precisamos
entrar como usuário para adicionar
o token JWT
ao cabeçalho de autorização
e depois enviar a mensagem. Vamos fazer isso muito rápido. Então, uma mutação repentina. Deixe-me esclarecer tudo isso. E na mutação de login, obteremos apenas o token JWT. Então, aqui, remova esse token JWT. Para as entradas, precisamos
do e-mail e da senha. Tudo isso. Portanto, o e-mail do
fuser two é usuário para adicionar email.com e a
senha é senha. Agora vamos fazer login. E lembre-se de que vamos
enviar uma mensagem para a sala ID1. Então, vamos usar o token JWT adicionado ao cabeçalho de
autorização. E seguro. Agora estamos conectados como usuário para, vamos voltar à mutação,
remover o sinal de qualquer mutação
e fazer login nas entradas. E aqui está a mutação de envio de
mensagem. Vou ter a
ideia da sala, a ideia dos usuários, talvez também do FirstName. E vou receber
todas as mensagens. Tudo bem, vamos adicionar as entradas. A entrada da mensagem,
a entrada do ID da sala. Então eu disse que vamos
enviar uma mensagem para o meu d1. E a mensagem é mensagem de usuário para usuário
, envie mensagens. E aqui vamos nós. Temos esse mesmo ID da sala, documento da
sala com
o ID da sala e os mesmos usuários e uma nova mensagem dentro
da matriz de mensagens. É assim que podemos enviar mensagens
usando o conceito de quartos.
37. Implementando validação com validador de classe: Agora vamos adicionar
validação ao nosso projeto. E para isso vamos usar os pacotes validadores de classe. Então, Sage ou um validador de classes de npm
e estilo de terminal. E a razão pela qual
vamos usar o
cluster, os dados, é porque os usuários de
dados classificados são decoradores. E vamos usar os
caracteres Class validator dentro das entidades para
verificar se temos, por exemplo um e-mail válido ou para aplicar certas condições
à senha. Então, primeiro, para validar um
e-mail da entidade do usuário, vamos importar
do validador da classe. O e-mail vai importar o
personagem. Então, este é um decorador
que podemos usar. Asse outros decoradores
de fraldas por aqui. Aplique o decorador a
esta propriedade por e-mail. E você pode ver dentro
da definição aqui que esse decorador verifica se
a string é um e-mail. Se determinado corpo não for uma string, ele retornará false porque qualquer homem deve
ser sempre uma string. Agora, para a senha, vamos validar o
tamanho da senha. Sim. Então aqui precisamos de outro, o personagem que
é o Min Nan. Em seguida, aplique-o na propriedade da
senha. Então, aqui, finalmente. E o mínimo, então,
para
a senha será seis
e salve o arquivo. Claro que você pode explorar mais. Os personagens do grupo
que o meditador acabou de escrever são assim. E você pode encontrar
muitos caracteres para validar muitas
coisas, como letras maiúsculas, como verificar se uma
propriedade é uma URL ou é uma matriz. E muitas coisas, como se
estivesse vazio ou não, ou estivesse em maiúsculas ou minúsculas.
E muitas coisas, sim. Então, verifique tudo isso e brinque com
o validador de classe. Agora vamos aprender como lidar com
a validação.
38. Pegar erros de validação: Agora, toda a validação
dos personagens será executada quando
criarmos uma nova entidade. E antes de salvar essa
entidade no banco de dados, usaremos
outro método do validador de classe para detectar
todo o erro de validação. Então, vamos examinar
o serviço ao usuário. E aqui, onde criamos
uma nova entidade de usuário, vamos primeiro importar o método, validar ou rejeitar
do validador de classe. E vamos usar esse método antes de
salvar a entidade do usuário. Aqui. Aguarde, valide ou rejeite. Em seguida, vamos
validar a entidade do usuário. E então vamos
usar o método de captura para capturar as vibrações
ou os erros de validação. Então, aqui vamos definir
um retorno de chamada que detectará os erros de validação de tipo,
validação e matriz de erros. E podemos importar esse tipo
do validador de classe. Então, aqui, erro
de validação de porta do validador de classe e
continue com o retorno de chamada. Então, vamos lançar novo erro do GraphQL se
tivermos algum erro. Sim, muito importante, o GraphQL. Graphql e enviarei de volta um
erro de validação de mensagem com extensão. Extensões. E nós vamos
devolver todas as flechas. Sim, com o código
que o usuário inseriu. Agora temos dois problemas aqui. A primeira é
que a senha será assediada. Portanto, se o usuário enviar uma senha de
três caracteres, obteremos uma, validaremos somente
a senha de risco, que é uma senha de sequência longa. Sim. E o segundo problema é que, embora estejamos
gerando um erro aqui, continuaremos passando uma execução, executando esta linha aqui, ainda
salvaremos o usuário. Então, para evitar
que tudo isso aconteça, vamos usar
o método then. E aqui dentro de um retorno de chamada. Vamos pegar esses nove. Adicionado aqui. Remova a senha
do método de criação e apenas dê uma aura. Basta deixar a
entrada de inscrição assim. E vamos mudar
a senha aqui. Certifique-se de que esse método seja assíncrono porque
vamos usar um peso. Agora, quando gerarmos a
senha, a senha, pegaremos a entidade do usuário e alteraremos a senha para que fique
igual à senha do hash. Tudo bem, agora
resolvemos o problema um. Agora, quanto ao problema, vamos devolver o usuário. Vamos salvar o
usuário e devolver o, salve um documento a partir daqui. E então
obteremos um resultado aqui. Esse resultado é o mesmo
que o usuário pode ver aqui. O resultado é do tipo
usuário porque aqui retornamos o usuário de lá. Portanto, usaremos apenas a declaração de
retorno aqui. E é isso. Ou, na verdade, cometemos
um erro aqui. Não devemos usar o
método dos gatos antes do método de então. Sim, então o
método de captura deve ser o último, o último método. Então, aqui, detecte todos os erros. Então, se
tivermos algum erro aqui, enviaremos um gráfico mais cedo. Mas se não
detectarmos nenhum erro, vamos executar
isso, voltar. Tudo bem, agora podemos
salvar esse arquivo e executar
o servidor a
partir do terminal. Então, aqui, eu
já fiz isso. E você pode ver que o node
man está reiniciando todas as reinicializações do servidor
porque alteramos o arquivo. E agora vamos testar nossa API
dentro do servidor Apollo, quero dizer, o sandbox acessível. Então, aqui temos nossa mutação de
inscrição. Então, vou enviar um
e-mail válido e uma senha válidos. Então, vou enviar uma senha de
três caracteres e executar a mutação de inscrição. E devemos obter uma validação. Vamos lá. Portanto, temos que obter
duas matrizes aqui e dizer que a
matriz de erros tem que se opor, significa que
obtivemos dois erros. O primeiro erro é
para o e-mail. Então, aqui, propriedade, e-mail. E você pode ver dentro dos contratos que temos sua
propriedade de e-mail. E com a mensagem, e-mail deve ser um e-mail. E para a senha da propriedade, você pode ver que
a senha da mensagem deve ser menor ou igual
a seis caracteres. Agora sabemos que nossa
validação está funcionando. Você pode adicionar mais validação
usando o validador de classe. Agora você pode validar
a entidade da sala e brincar com
os dados de agrupamento. Agora, antes de terminar este vídeo, quero observar que se você fechar o banco de dados Postgres
pressionando Control C, assim, você terá n e depois reescreverá novamente com
o comando docker run. Você precisa fechar o servidor GraphQL pelo
Control C e executá-lo novamente. Sim, execute-o novamente quando agora o banco de dados Postgres estiver pronto
para aceitar conexões. Caso contrário, você
receberá muitos erros e não conseguirá
trabalhar com o banco de dados.
39. por que devemos usar o ScoketIo: Agora podemos enviar
mensagens entre usuários, mas para que um usuário
veja a mensagem mais recente, ele precisa recarregar
o navegador ou, por exemplo ,
aqui, estamos usando o sandbox. Precisamos buscar todas as
salas para ver as últimas mensagens enviadas
pelo participante dessa regra. E você sabe que os usuários não vão gostar disso porque todos os aplicativos de
mensagens agora
têm algum tipo de mecanismo de transferência de dados em
tempo real para que os usuários possam receber e ler novas mensagens em
tempo real sem luz, atualizando a página ou fechando um aplicativo e reabri-lo novamente para buscar as salas e receber as mensagens mais recentes. E esse é o recurso que precisamos implementar
em nosso aplicativo. Então, vamos usar o Socket IO, uma
biblioteca muito popular que permite comunicação
em tempo real entre clientes e servidores
da web. Você pode navegar até o
socket dot io, ler a documentação e
ver alguns exemplos. Sim, mas é claro que
vamos trabalhar com Socket IO neste projeto e começaremos
no próximo vídeo.
40. Junte-se a quartos com socketIo: Agora vamos começar instalando o
soquete IO do MPM. Então abra seu terminal e
execute npm install socket IO. Tudo bem, agora vamos
abrir o módulo, o arquivo ts e implementar
o servidor de soquete IO lá. Aqui, deixe-me fechar o terminal. Abra o fogo de lágrimas modulares. E a primeira coisa que
precisamos fazer é importar a classe do servidor
do soquete desse IL. Agora vamos implementar
o servidor de soquete IO dentro
do método automático de inicialização e implementado com
o servidor HTTP. Então, aqui vamos criar
a
constante A0 e criar uma
nova instância do servidor, passar o servidor HTTP. E agora temos que começar a
ouvir as conexões. E podemos fazer isso
com o método on e ouvir o
evento de conexão aqui, conexão. Em seguida, vamos
adicionar e voltar aqui. Isso vai ganhar um soquete. E faremos algo
com esse tipo de aposta. Então, para poder usar o soquete dentro de
todos os nossos resolvedores, vamos colocá-lo
dentro da solicitação e obter acesso à
solicitação a partir da constante de anúncio. Em seguida, solicite e crie uma propriedade personalizada,
chame-a de soquete IO e
defina-a como o soquete que
recebemos do cliente. Agora temos que adicionar a propriedade
IO do soquete à interface de
solicitação e faremos isso
dentro do arquivo main.js. Então, vamos abri-lo. E dentro dela, vamos declarar uma variável
global ou namespace. E vamos selecionar
o namespace express. E dentro dela, vamos
selecionar a solicitação de interface. E aqui podemos adicionar o soquete IO e torná-lo desnecessário. E então o soquete IO será do tipo soquete. Podemos importar esse tipo
do pacote IO do soquete e depois salvar esse arquivo e depois voltar para o
módulo, o arquivo ts. E você pode ver
que o erro é o erro desapareceu. Agora. Como estamos usando
o conceito de salas nosso aplicativo, podemos fazer a mesma
coisa com o Socket IO. Então, vamos usar
o soquete do cliente para unir todas as salas
que o usuário tem. E então, sempre que emitimos um novo evento para uma
dessas salas
e, claro, eu tenho uma tomada que
não entrou na sala, ela não receberá o evento. Então, vamos fazer tudo
isso dentro do contexto. E aqui temos que
verificar se, se temos uma carga útil. Sim, se sim, vamos buscar todas as salas do banco
de dados. Para poder fazer isso, precisamos criar uma constante aqui e obter a instância de
origem atualizada. Então, aqui, crie nossa fonte de dados. E vamos
usá-lo para caber em todos os quartos. Então, aqui na Data Source, gerenciador de
pontos, vou usar o gerenciador e depois o repositório
Git. E nós vamos pegar
o repositório da sala. Portanto, importe a
entidade da sala e use-a aqui. Espaço para isso a partir daqui. E portar a entidade da sala. Da pasta dos quartos
dentro da sala. Selecione as entidades NSAID
como a entidade da sala. Agora, aqui usamos a sala para
selecionar o repositório da sala. E então usaremos, criaremos um construtor de consultas, um alias para a sala. E então vamos selecionar todas as salas que
contêm o ID do usuário. Então, para isso, precisamos usar inner join para unir todas
as tabelas de usuários dos usuários
do Rome dot e adicionar um
alias para a matriz de usuários. Em seguida, adicione uma
condição where aqui e
percorra toda a matriz de usuários e selecione
apenas todos com uma ID de usuário igual
à variável ID. E vamos obter
o ID do usuário
da carga, esse ID de usuário. Tudo bem, agora vamos adicionar outro método aqui
para obter muitos quartos. E aqui vamos criar uma
constante e chamá-la de Salas. E aguarde o
resultado. Tudo bem. Agora, aqui vamos obter
uma matriz de objetos Forms. E então vamos usar o soquete IO da
solicitação para juntá-los. Então, aqui, o
soquete Quest Dot IO que se junta. E esse método
nos
permitirá adicionar salas ao soquete. E você pode ver aqui que podemos adicionar um único quarto
ou uma variedade de formulários. Agora, precisamos de uma
referência exclusiva para, é verdade. Para nós. Temos o ID do quarto como
referência, mas é um quarto. É, a referência da sala
deve ser uma string. Então, aqui temos uma string e aqui temos uma
matriz de strings. Mas, como você sabe, os IDs dos quartos são números. Então, vamos
convertê-los em cadeias de caracteres. E vamos criar
uma matriz de IDs de strings. Aqui, crie um Rooms IDs
e, em seguida, pegue a
matriz de salas e mapeie todas as salas e retorne uma string usando
a string literal e retorne o id do ponto da sala. Agora temos uma matriz de cadeias de caracteres. Então, vamos passar isso aqui. IDs de quartos. Tudo bem,
agora terminamos. Mas aqui temos um erro dizendo que a
carga não tem uma propriedade de ID de usuário e
que a carga é do tipo string ou uma paleta JWT. Podemos corrigir isso
verificando se o tipo de carga útil não é
igual à string. E temos que verificar
se temos uma carga útil. Sim. Em seguida, podemos usar
a propriedade ID do usuário. Agora, é assim
que podemos unir salas. No próximo vídeo,
aprenderemos como
emitir eventos para um grupo específico.
41. Emite mensagens em uma sala específica: Agora, para emitir eventos, precisamos usar a constante IO,
que representa a instância de IO do
soquete, e passá-la
para o valor de retorno
dos métodos de contexto para que possamos usá-la dentro de nossos resolvedores. Então, aqui dentro desse objeto, adicione A0 e salve o
modelo no arquivo ts. Em seguida, dentro do arquivo de serviço Room
Dots. Aqui, vamos usar
a instância de IO dentro do método
ad message to room. Então, aqui vamos adicionar
como argumento do tipo servidor e garantir que você
adicione o ponto de interrogação aqui. Porque às vezes
isso pode ser conhecido. Agora, para o servidor aqui, pode importar isso do pacote de
soquete IO. E depois de atualizarmos a sala e adicionarmos uma nova
mensagem à matriz de mensagens, podemos verificar aqui. Se não tivermos IO
, nesse caso, emitiremos um novo
evento usando o método image. Agora, esse método
aceita dois argumentos. O primeiro argumento é
o nome do evento e o segundo argumento
é qualquer tipo de dado. Pode ser uma matriz ou objeto, uma string ou até mesmo um json. Agora, novamente, Jason é
apenas a corda. Então, aqui podemos nomear
a mensagem do evento. E para os dados aqui, enviaremos um objeto contendo a mensagem
e o ID da sala. Agora, nesse caso, emitiremos esse evento
para todos os usuários conectados. Mas nós não queremos isso. Queremos emitir essa
mensagem para uma regra específica. Então, vamos usar outro método aqui
antes que eles emitam. Esse método é o método e passa o
ID da sala como uma string. Então, vamos usar a
sequência literal e adicionar o ID da sala. Agora, emitiremos essa
mensagem, esse evento, para apenas dois usuários que
participaram desta sala. Agora, vamos salvar isso. E dentro da sala que resolve e dentro do resolvedor de mensagens de
envio. Vamos passar o IO aqui além do AL a partir do
contexto que I0. É isso. Agora, vamos salvar
isso e esse é o APR.
42. Testando o servidor Io: Não podemos ouvir eventos
usando o sandbox Apollo. É por isso que criei um
aplicativo muito simples onde podemos enviar e receber mensagens
ouvindo eventos. E toda essa lógica está
dentro do arquivo index.js. Você pode ver aqui que estou me
conectando ao servidor. E aqui eu tenho algumas dúvidas e mutações para enviar a mensagem. E aqui estou ouvindo
o evento Connect e
o evento de mensagens. E como você pode ver aqui, estou analisando os dados
no documento HTML. Portanto, para executar esse servidor, você precisa ter uma extensão
chamada Live Server. Então, aqui você precisa procurar a extensão do
servidor ativo e instalá-la em seu VSCode. Então você descobrirá que obteria um botão aqui.
Deixe-me desconectar. Sim, você encontrará um
botão que diz Go Live, clique nele e então você
terá um servidor ativo. Então, deixe-me executar novamente o servidor e começar a testar
o aplicativo. É isso, essa é
a simplificação. Eu só tenho um lugar onde preciso colocar o
token JWT e fazer login. Então aqui
enviaremos as mensagens. Eu tenho dois navegadores aqui, então duas instâncias
do mesmo aplicativo. Agora, precisamos habilitar o
curso dentro do servidor de soquete IO para podermos nos
conectar usando esse URL. Então copie isso. E então aqui dentro do
módulo, do arquivo ts e dentro do servidor Stockdale, vamos adicionar um novo objeto e
definir a opção de curso. Defina a origem
desse URL e salve-o. Então, vamos voltar aqui
e verificar se você reiniciou seu servidor. E vamos pegar o token
JWT na sandbox. Então, aqui, certifique-se de
fazer login e, em seguida pegar o token JWT, copiá-lo e depois colá-lo em um
desses aplicativos. Clique em fazer login. E então eu entrei como outro usuário e
salvei o token. Então, vou colar aqui. Certifique-se de fazer a mesma
coisa. Clique em fazer login. E agora vamos testar o servidor, entrar no alto da areia
e não funcionou. E isso porque
aqui, tudo bem, temos que remover o
lodo do final da URL. Então, vamos voltar ao
módulo, até agora. Remova o lodo de lá e verifique se o
servidor foi reiniciado. Vamos esperar e testar novamente. Tudo bem, você pode
ver que agora estamos conectados porque temos
a mensagem conectada aqui. Agora, se eu clicar na areia, deveríamos chegar bem alto aqui. E aqui talvez tenhamos que
recarregar o aplicativo. Então, vamos copiar o token JWT, recarregar e
clicar em fazer login novamente. E talvez a mesma
coisa aqui, porque
temos que nos unir aos quartos. E antes, acho que
não fazíamos isso no servidor. Então, vamos entrar e enviar alta. Tudo bem, recebemos a
mesma mensagem dentro
das duas instâncias aqui que
enviamos aqui como olá. E aqui está, nosso
aplicativo está funcionando. Agora, como eu disse no
início deste vídeo, você encontrará o código-fonte anexado para poder
baixá-lo e testá-lo sozinha.
43. Migração de banco de dados: Agora terminamos de
desenvolver nossa API, mas ainda precisamos
lidar com uma coisa, que é o caso em que
queremos atualizar nossas entidades. Nesse caso, também precisamos
atualizar nosso banco de dados. Então, por exemplo se você quiser mudar aqui
FirstName para only name, é
claro que precisamos
atualizar nossos arquivos, mas o mais importante, precisamos atualizar nossas tabelas de banco de dados. Agora, se o vendermos, coloque
nosso projeto, incluindo o
banco de dados, em produção. Portanto, não temos
dados de importação. Podemos desligar o
banco de dados e executá-lo novamente para remover todas as tabelas e
criar novas. Mas se já colocamos nosso
projeto em produção, temos usuários ativos. Por exemplo, nesse caso, não devemos seguir a primeira
abordagem porque não
queremos perder
todos os dados de nossos usuários. E também será um
grande desastre para nosso aplicativo. Então, o que devemos fazer aqui, bem, a fonte de dados do aplicativo, temos essa propriedade
sincronizada definida como verdadeira, significa que vamos
atualizar nossas
tabelas de banco de dados toda vez que você fizer
uma alteração em nossas entidades. Essa substância
mudará apenas os nomes e tipos de algumas colunas, mas não
preservará nenhum dado. Portanto, essa opção é
tão perigosa quanto desligar o banco de dados
e executá-lo novamente. Resumindo a história,
a única maneira de
evitar a perda de dados é usando algo
chamado migração de banco de dados. Há muitas
maneiras de fazer isso. Mas com o type ramp, podemos gerar
automaticamente arquivos que contêm consultas secretas que serão
responsáveis pela integração. Então, em certo sentido, a
opção de sincronização é falsa e segura. E você precisa ter
certeza de que temos um banco de dados em execução usando
o comando Docker. E temos que executar nosso servidor que possamos criar as
tabelas de usuários e os tipos de ossos. Tudo bem, agora vamos até a entidade
do usuário e mudar primeiro nome para o nome e depois
gerar uma migração. Então, aqui, nomeie, salve isso e vamos atualizar
o esquema GraphQL aqui de FirstName para name. E a mesma coisa,
site do
tipo de usuário , FirstName, tunic, Save. E aqui vamos
gerar o esquema. Ele falhou porque temos que gerar isso,
saiu por nós mesmos. Então, aqui npm run generate e , em seguida, vamos
executar o servidor novamente. Tudo bem, o npm começa. Agora não vamos
atualizar o banco de dados
porque temos a
opção de sincronização definida como false. Então, vamos esperar
pelo servidor aqui
e, em seguida, geraremos
os arquivos de migração. Tudo bem, agora vamos
abrir outro terminal. E para gerar a
negação do Phi é que precisamos
instalar esse programa globalmente dentro do nosso projeto
usando este comando. Sim. E às vezes você precisa adicionar a palavra-chave para
obter privilégios de administrador. E se você estiver dentro de uma
máquina Windows e precisar
abrir um console de administrador. Portanto, não vou fazer
isso porque já estou usando rampa de
partida global
dentro do meu sistema. Então, vou prosseguir
para a próxima etapa, que é usar o NP x, que é um pacote que vem por padrão
sem GS e NPM. E vou rodar a
fita usando
o node ts e o
módulo CommonJS para JavaScript. E vamos
executar a regressão, gerar
Carlin e especificar a localização
de nossos arquivos de iterações. Eu quero a pasta de origem dos sites e dentro de uma pasta de migrações. E então obteremos arquivos com data e hora e palavra-chave de migração. Então, vamos obter
arquivos com timestamp, faz ponto de regressão Sim. Ok, agora temos que especificar
a localização da fonte de dados do
aplicativo. Então aqui, fonte de dados
holandesa que sim, é isso. Vamos executar esse comando.
E aqui vamos nós. Geramos com sucesso as lutas de imigração ou um arquivo. Nesse caso. Esse arquivo é um arquivo TypeScript com uma classe. E aqui você pode ver a
duração do nome e a data e hora. Então, aqui temos dois
métodos para cima e para baixo. Portanto, o método add será executado toda vez que
executarmos isso, toda vez que executarmos
essa migração. E vamos executar essa consulta sequencial que
mudará primeiro nome para nome. Agora, o método down pode ser usado para reverter as imigrações
, conforme representado aqui. Você pode ver a consulta aqui que mudará
o nome para FirstName. Então, se mudarmos de ideia e
quisermos reverter a imigração, podemos executar o método da cidade. E, claro, tudo
isso será executado automaticamente
usando o tipo RAM CLI. Agora, para executar essa regressão, há duas maneiras de fazer isso. Primeiro, podemos usar o mesmo
comando aqui, mas alterado. Apenas algumas coisas, como
manter a fonte de dados mover esses nove para cá e
alterar sua taxa de execução. É isso. E podemos administrar a
imigração e
obteremos um banco de dados atualizado. Você
pode fazer isso ou executar a migração
dentro ou a partir da fita automaticamente usando
a fonte de dados aqui. E ao adicionar a imigração, imigração é uma propriedade administrada. E vamos especificar
onde nossas migrações estão localizadas. Então, porque a tênia aqui
não pode executar o vício de Ts, obviamente. Então, vamos apontar para
a pasta dist que contém
as migrações GS, gorduras. Então aqui, isso e depois a fonte, e depois dentro da pasta de
emigrações. Em seguida, execute todos os arquivos que têm uma migração holandesa gs e terminam com a extensão
dot js. Sim, então vamos salvar isso. E, na verdade, não são migrações, integrações de
botões Executar. É isso. Usaremos
as migrações executadas para especificar que queremos executar todas as migrações quando
executamos esse servidor. Então, aqui está definido como verdadeiro. Agora vamos salvar isso e ver se nosso
servidor está reiniciando. Tudo bem, agora vamos
tentar nos inscrever. E desta vez não
vamos usar FirstName, mas vamos
adicionar apenas nome. Aqui mesmo dentro da
caixa de areia, caixa de areia Apollo. Vá para uma mutação e selecione
a mutação de inscrição. Então, aqui, inscreva-se na
mutação e
aguarde o token JWT ou as entradas. E você pode ver aqui que
atualizamos o equipamento gráfico, mas não significa que
atualizamos também o banco de dados. Mas vamos verificar
isso em apenas um minuto. Sim. Vamos adicionar
tudo isso aqui. E deixe-me expandir isso. Tudo bem, escolha qualquer e-mail. E-mail, email.com, sobrenome, nome de
usuário, digamos John. Senha. Senha.
Vamos nos inscrever. E devemos obter o token JWT. Se
atualizarmos o banco de dados com sucesso
e
tivermos feito isso com sucesso, temos aqui o token JWT e temos um usuário em
nosso banco de dados com o novo nome da propriedade
em vez de FirstName. Então, deixe-me considerar se podemos
devolver o usuário aqui, tudo bem, nós podemos, então deixe-me retornar
todos esses campos. E vou me inscrever
com outro e-mail, talvez tenha um usuário, e pronto. Vamos nos inscrever. Vamos lá. Temos aqui um conjunto de
nomes de FirstName. Portanto, atualizamos com sucesso nosso banco de dados usando
a imigração. Então é assim que podemos fazer isso. Mas certifique-se de sempre definir
isso como falso. Ou ele pode simplesmente
removê-lo daqui. Vou guardá-lo
apenas para lembrá-lo que essa propriedade
tem que ser falsa. E para as imigrações, precisamos sempre
executar arquivos GFS. E você pode ver dentro da pasta
dist que temos pasta de
imigração. Aqui
temos dois arquivos para
a imigração. E isso porque eu testei essa API e tentei
executar a migração. Mas quando temos vários níveis, arquivos de
migrações e
você os exclui aqui,
não significa
que eles serão
excluídos junto à pasta dist. Portanto, sempre certifique-se de remover
a pasta dist aqui e de gerar uma nova toda vez que executar a API. Caso contrário, você executará todos os arquivos de integração e corromperá
seu banco de dados. E lembre-se também de
fazer a mesma coisa. O site aqui removeu as imigrações porque já as
executamos. Mas se quiser, você pode manter os arquivos de imigração
em outro local. Sim. Não necessariamente. Coloque o lado da pasta do projeto. Nesse caso, você pode usar o método down para reverter a imigração
se quiser fazer isso. Sim. Então, para nós, não
é
grande coisa porque estamos apenas mudando FirstName para nome. Então, eu vou deletar toda
essa pasta. E é isso. Agora, sempre que quisermos
migrar o banco de dados, obteremos novos arquivos e os executaremos a partir do
tipo em torno da fonte de dados. Agora, antes de terminar este vídeo, quero mencionar uma
coisa: se você quiser executar as migrações
usando este comando, você precisa ter a
propriedade migrações dentro da fonte de
dados, certo? E você pode adicionar migrações, executar ou simplesmente removê-las de lá. Isso importa? Mas para executar esse comando, você precisa ter a propriedade
immigrations e especificar o local das migrações. E é isso.