Transcrições
1. Nestjs para iniciantes: curso Introdução: Olá e bem-vindo ao
meu curso sobre STS, uma estrutura progressiva do Node
JS para criar aplicativos web eficientes e
escaláveis. Ses é uma estrutura que combina
o melhor dos dois mundos, o poder e a flexibilidade
dos nós, sim, com a elegância e
simplicidade do TypeScript. Isso sim, fornece um modelador, na verdade, dependência
tectórica,
injeção, tratamento de exceções, utilitários de
teste e muito mais. Neste curso, você
aprenderá a usar
menos apenas para criar um aplicativo de blog com autenticação usando a célula
desprevenida Mongoose. Você também aprenderá
como configurar seu ambiente de desenvolvimento
e instalar um STS. Crie controladores, serviços, módulos, guardas e decoradores. Use o nests CLI para gerar
código e executar comandos. Conecte-se a um
banco de dados MongoDB usando o Mongoose, os esquemas finos, modelos, interfaces e vídeos, além operações
codificadas para
postagens de blog e ações do usuário. segurança ou os endpoints com autenticação e
proteções do
JWT lidam com erros e
exceções com elegância. Este curso foi desenvolvido para
iniciantes que desejam
começar com um SES ou melhorar
suas habilidades existentes. Você não precisa de nenhuma
experiência anterior com um STS, mas deve ter algum conhecimento
básico de Node.JS, JavaScript e um
pouco de TypeScript. A propósito, se você quiser aprender mais sobre NodeJS
e TypeScript, tenho outro
curso sobre escultura, que
abrange tudo o que você
precisa saber. Observe que, no curso,
você aprenderá a usar o NodeJS para criar olhos de API
RESTful, aplicativos
em tempo real, servidores
GraphQL e muito mais. Você também
aprenderá a usar algumas
das estruturas
e bibliotecas mais populares que
funcionam com nós,
sim, como explicitamente
como Mongoose,
soquete IO, rampa de tipo,
validador e muito mais. Esse curso foi elaborado para prepará-lo para usar o Nes Yes e fornecer uma
base sólida de habilidades de náusea. Então, se você estiver interessado em
aprender náuseas, tristeza, melhorar suas habilidades existentes, eu recomendo fortemente que você
confira meu outro curso
no Skillshare. Agora, essas
pontuações resumidas são estruturadas de uma forma específica que segue as melhores práticas
de desenvolvimento web. Sua seção abrange um tópico
específico com explicações,
exemplos e exercícios claros. Você também pode baixar
o
código-fonte de cada seção
e acompanhar. Você também terá acesso a uma
comunidade amigável e solidária de colegas e instrutores do
Skillshare que estão prontos para ajudá-lo sempre que
você tiver dúvidas ou dúvidas. Então, o que estamos esperando? Inscreva-se agora e comece a
aprender NES ontem.
2. gerar seu primeiro projeto de Nestjs!: Bem-vindo ao primeiro capítulo
do módulo loudness js. Neste capítulo,
vamos mergulhar no mundo empolgante de Nicias e aprender como criar um aplicativo de blog
simples com autenticação. Estou dentro do
eficiente site da SES. Sinta-se à vontade para dar
uma olhada e explorar a umidade que
isso tem a oferecer. No entanto, não se preocupe se você se sentir sobrecarregado, porque
neste módulo, estamos fornecendo
todas as informações que você precisa para começar a Nestea, abordaremos o básico e criaremos um aplicativo
do mundo real. Podemos começar a usar o
Nicias com confiança. Agora, o que vem a seguir? Sim. Let's us é uma estrutura
que se baseia
na popular
estrutura extra de CS para NodeJS. Mas, ao contrário do express, o JS fornece uma estrutura mais modular e escalável
para seu aplicativo, ele também incorpora muitas
das melhores práticas e
padrões de design usados no Angular. Você não precisa ter
nenhum conhecimento prévio de Angular para entender o STS. E, de fato, os projetos
que construímos juntos
no módulo anterior usando Node.JS expressos em TypeScript já
deram uma ideia de como essa estrutura amarela
é sua aplicação. Neste módulo, vamos nos
aprofundar em um STS e em como ele pode ser usado para criar aplicativos
escaláveis e de fácil manutenção. Também utiliza o poder
do TypeScript e da
arquitetura Angular mais recente para tornar a criação de
aplicativos do lado do servidor mais eficiente e agradável. E neste módulo,
usaremos a CLI, ou interface de linha de comando, que é uma ferramenta incrível que nos
permite gerar facilmente um novo projeto com todos os arquivos e
diretórios necessários para começarmos. Agora, antes de
entendermos isso, sim. PMPM instalado pelo Cli be npm é um gerenciador de
pacotes rápido e eficiente em espaço em disco para a Nokia. Isso economiza
espaço em disco e garante que você não
perca tempo com
instalação e manutenção. O APM também está disponível
em Windows, Linux e Mac. Para interromper o NPM, você precisará ter o NPM ou o Yarn instalados
em seu sistema. Depois de instalar um desses
Gerenciadores Pacotes,
abra seu terminal e execute o
seguinte comando. Se você estiver dentro do Linux, você usará o npm. Instale esses C, P e B F. Mas se você estiver em
janelas laterais como eu, você tem que usar fios para isso. Ela não bloqueia o PMPM como um pacote
global, então P NPM. Tudo bem, depois disso,
você pode instalar a CLI do Azure executando
o comando npm. Adicione esse G. Então vamos nos ver. Cli, eu tenho BI
e BPM e SES yellow
já instalados. Assim, quando a instalação
estiver concluída em seu site, podemos usar a CLI para
gerar um novo projeto. Vamos dizer que
o blog tem que fazer isso. Vamos executar o comando nest, então você conecta o Dash. Como você pode ver, podemos acessar a CLI do Azure com o
nome nest e usar
a nova tag para gerar
um novo projeto de aplicativo de blog. Agora aperte Enter. Vamos apenas solicitar que você escolha entre esses
três gerenciadores de pacotes. Então, se você instalou o
PMPM como eu, você pode escolher o PMPM, selecionar o NPM e pressionar
Enter. Mas se você não fez isso, você pode escolher
entre NPM ou Yarn. Eu já fiz isso. Então, quando você terminar, você terá um
novo projeto SES pronto para ser usado em
um aplicativo de painel de blog. Portanto, na raiz do nosso projeto, você encontrará vários arquivos
de configuração comuns
à maioria dos projetos. Esses arquivos contêm
informações importantes sobre nosso projeto. Isso diz que dependências e scripts dentro da sacola são Jason. Mas um dos conselhos mais
importantes é o erro ES lint. Veja, esse arquivo é usado para configurar as
regras de linting para nosso projeto. Isso nos ajuda a manter nosso código
limpo e sustentável,
garantindo que sigamos
as melhores práticas
e padrões. É por isso que eu
recomendo fortemente que você instale uma extensão com o nome
ES lint sides your VSCode. Com esta seção, você receberá feedback
e sugestões
em tempo real sobre como melhorar seu código. Então, vá em frente e instale o AS e a extensão ao lado do seu VSCode. Tudo bem, vamos
voltar ao projeto. Você também notará
uma pasta de teste e a raiz do projeto. Essa pasta contém
dois arquivos importantes, o arquivo adjacente e o arquivo txt do
app spec dot. Portanto, o arquivo JSON é apenas
um arquivo de configuração
apenas para uma estrutura de teste popular
para projetos de JavaScript. Sim, ele configura o
ambiente de teste para o seu ninho. Aplicação. Sim. E para a
especificação superior, o arquivo ts, esse é um exemplo de um teste de ponta a ponta
para seu aplicativo. Portanto, testes de ponta são usados para testar
a queda do império de seu aplicativo do início ao fim, para garantir que tudo
esteja funcionando corretamente. Agora, o resumo,
o arquivo ts, prejudica a resposta do
ponto final raiz do seu aplicativo. Ele usa a biblioteca
de teste de suporte para enviar uma solicitação ao aplicativo
e testar a resposta. Essa é uma ótima maneira de garantir que seu aplicativo esteja funcionando conforme esperado e detectar quaisquer problemas logo no início do processo de
desenvolvimento. No geral, a pasta de teste e os arquivos nela
contidos desempenham um
papel crucial para garantir a qualidade e confiabilidade do seu
Nestea, este aplicativo. Agora vamos voltar
ao arquivo package.json. Aqui, podemos ver vários scripts ou
comandos escritos que podemos usar para executar e gerenciar
nosso aplicativo. Esses scripts tornam nosso processo de
desenvolvimento muito mais fácil e simplificado. Alguns dos scripts mais
importantes incluem o script inicial. Esse comando é usado para iniciar o aplicativo no modo
de desenvolvimento. Quando executamos npm, npm bland
starting to terminal, ele compilará e iniciará o aplicativo na
porta especificada. Sim, mas eu prefiro, ou todos os desenvolvedores
preferem executar essas chamadas iniciais, porque esse comando aqui
conterá a tag de observação de dados que nos permite
executar o aplicativo e o que muda
ao mesmo tempo. Agora também temos
o script de construção. Esse script é usado para compilar e criar o aplicativo
no modo de produção. versão compilada
do aplicativo estará pronta para ser implantada. E vamos
colocar essa pasta dentro do diretório
do nosso projeto. Também temos o script de teste. Estamos usando o script para executar os casos de teste
do aplicativo. Podemos usá-lo para
garantir que nosso aplicativo esteja funcionando conforme o esperado
antes de implantá-lo. E talvez um novo comando
para nós seja o comando lint. Esse comando é usado para executar o processo de linting em nosso código. O Linting nos ajuda a manter o estilo de código do
ecossistema e a evitar erros comuns
de codificação. E vamos falar sobre
o formato ou o comando. Esse comando, o formato é usado para formatar nosso
código de acordo com as regras especificadas nas configurações de
linting dentro do arquivo GIS terrestre ARC dos EUA. Você pode brincar com essas configurações
conforme desejar. Mas as configurações padrão fornecidas por um STS
são mais do que suficientes. Sim, então vamos fechar isso. E, em geral, essas faixas dentro do maior arquivo
adjacente são muito úteis para automatizar
o processo de desenvolvimento e facilitar
o gerenciamento de nosso aplicativo. É importante
entender o que cada um
desses roteiros é estrelado
e como podemos usá-los a nosso favor. Tudo bem, agora vamos
para a pasta SRC examinar cada arquivo dentro dessa pasta e
explicar seu propósito. Temos o arquivo main.js. Esse é o ponto
de entrada do nosso aplicativo. Ele cria uma instância
do aplicativo e começa a
ouvir a porta especificada. Também temos o
módulo app dot que tem um arquivo. Este é um modelo que agrupa
todos os controladores, serviços, vibrações e
muito mais em um único teto. É semelhante ao conceito
de módulos em Angular. Também temos o aplicativo
dot controller.js. É aqui que definimos nossas rotas e lidamos com as solicitações
recebidas. Ele usa os maiores
, como GET ou post, que não são fornecidos
para app.get ou abduct post em expresso. A classe do controlador no
SES é responsável por definir os endpoints e lidar com as solicitações HTTP recebidas. método dentro
do controlador representa uma rota
em seu aplicativo. Os métodos podem lidar com diferentes tipos de
solicitações, como
GET , post, PUT, delete etc. Isso já é feito com a
ajuda de decoradores, como a categoria posterior, que é equivalente ao método
get no Express. Agora temos também o curador do
controlador. Isso é usado para identificar
a classe como um controlador. Isso é importante
porque nos permite saber que essa classe deve lidar com solicitações HTTP recebidas. Tudo bem, vamos passar para o arquivo
abducts services.js. Agora, é aqui que
colocamos nossa lógica de negócios. É um ótimo lugar para colocar
qualquer consulta de banco de dados ou outra lógica complexa que nossos
controladores precisem usar. Temos o injetável, quanto maior for
o uso
para identificar classes que podem ser injetadas como dependências
em outras classes. Em nosso exemplo, temos a classe
App Service that yes
, marcada como injetável. Isso significa que
ele pode ser usado como uma dependência em outras
partes do nosso aplicativo Podemos injetar o vidro do App
Service no controlador usando
o decorador
injetável e, em seguida, chamar o método get's hello
da classe App Service sob
nosso controle, como
você pode ver aqui. Agora, essa é uma maneira poderosa de
gerenciar dependências
em seu aplicativo, facilitando o
teste e a manutenção seu revestimento. Organizando
seu código dessa forma, você pode garantir que
seu controlador esteja se concentrando em lidar com as solicitações
recebidas. Por que a classe de observadores pode ser usada para lidar com uma lógica
mais complexa. Agora que
configuramos a estrutura do projeto, vamos executar o servidor e verificar a resposta do roteador hello
world no navegador. Para fazer isso, executamos o
comando npm run start, site ,
nosso terminal ou PMPM porque
nós o instalamos. Então seja npm, corra, comece a cair, morra
e aperte Enter. Obviamente, precisamos
navegar até um blog que esteja ativo. E então vincule o
comando mais uma vez, seja npm run start going in there. Tudo bem, se você obtiver
esta última linha aqui, aplicativo foi
iniciado com sucesso, significa que você
iniciou sua inscrição com sucesso. Agora vamos
abrir o navegador e testar uma resposta para o Hello
World. Aqui, vamos navegar
até localhost thousand e
aguardar a resposta. E aqui está, a corda
Hello World. Agora você pode perguntar
como fizemos isso, embora dentro do controlador. Deixe-me reduzir isso,
esse roteador aqui, esse método representa o ponto final
raiz da nossa API. Eu posso mudar isso
adicionando uma string dentro
do decorador get
assim, por exemplo, hello. Em seguida, salve. Dessa forma. Vamos colocar a sequência Hello World
dentro da rota Hello World. Vamos voltar ao navegador. Deixe-me primeiro navegar até
a raiz e o ponto
de aplicação. Você pode ver que não podemos obter o ponto final raiz de nossa API. E isso porque
mudamos para Hello. Como você pode ver, isso é
muito simples por causa
da ajuda das niveladoras
que estão dentro das redes. Sim. Agora, configuramos com sucesso em unidades, sim, Projeto. E temos uma
compreensão básica de sua estrutura e principais lutas. No próximo capítulo,
nos aprofundaremos
nos controladores, serviços e modais e em como
usá-los adequadamente.
3. Configurando mongóis: Olá a todos. Neste vídeo,
começaremos com um
projeto bem estruturado que você encontrará na seção de
recursos. Então vá em frente, baixe-o e abra-o dentro do seu VSCode. É importante
dedicar um momento para
entender a estrutura do nosso projeto e por que o
dividimos em componentes
menores. Nosso aplicativo está organizado
em quatro diretórios principais, o diretório do aplicativo e, dentro dele o autor, o blog e o usuário final. Cada um desses
diretórios contém um conjunto de componentes
com uma função específica. Agora, o diretório do aplicativo é o diretório principal
desses três componentes. E ele contém o modelo de
pontos do aplicativo, o arquivo ts. Mas não vamos trabalhar
com isso no momento. Mas cada um desses
diretórios contém um conjunto de componentes
com uma função específica. Esses componentes são ainda
divididos em controladores, serviços e tabelas de esquema. Mas o diretório está vazio
por enquanto porque
vamos adicionar arquivos
e configurações muito
específicos por meio dele. Sim, mas agora vamos
trabalhar apenas com esses
dois componentes, o blog e o usuário. Portanto, essa estrutura nos ajuda a gerenciar e manter o
código com mais eficiência, além de facilitar
a escalabilidade do aplicativo. exemplo, quando adicionamos novos componentes
ou expandimos os existentes, eles não afetam o
resto do sistema. Além disso, esse
detector desacoplou diferentes partes de
nossa aplicação, tornando-a menos
dependente dos
detalhes de implementação de outras partes. Por fim, a organização estruturada de
arquivos torna mais fácil para os desenvolvedores entenderem as diferentes
partes de nosso aplicativo, como elas se encaixam e
como todo o sistema funciona, tornando-a a melhor prática
a ser seguida no desenvolvimento de SDS. Agora, em resumo, nossa estrutura de
projeto resulta em melhor
escalabilidade de gerenciamento de código para lidar com links e facilitar
a compreensão do design geral do sistema. Tudo bem, agora neste projeto, usaremos o MongoDB
como nosso banco de dados para
armazenar nossas postagens de blog
e informações de usuários. Trabalhamos com o MongoDB
e, honestamente, com o projeto Yes. Usaremos a
popular biblioteca de
modelagem de objetos MongoDB , Mongoose. Mongoose fornece uma solução simples
e elegante para definir esquemas,
validar dados e consultar o banco de dados
MongoDB com Mongoose
para poder interagir facilmente com nosso banco de dados MongoDB
e modelar nossos dados uma
forma que faça sentido
para nosso aplicativo. Então, vamos começar e integrar uma ideia
em nosso projeto. Primeiro, navegaremos
até o
site de outros usuários do MongoDB para atualizar
nosso URI do MongoDB. Então, aqui, se você não
tiver uma conta, você pode clicar neste botão drive for
EE e criar uma nova conta. Ou, se você tiver uma
conta, basta entrar na seção de clusters. Se você é novo no MongoDB, você pode criar um
novo cluster usando esse botão e,
em seguida, escolher o cluster compartilhado para obter um plano gratuito e, em seguida, criar o cluster
clicando nesse botão. Depois de terminar a partir disso, volte para a
seção de clusters, clique em Conectar
e, em seguida, conecte
seu aplicativo. E esse é o URI do MongoDB. Vamos usar esse URI para conectar nosso projeto ECS
ao banco de dados MongoDB. Certifique-se de não selecionar nenhum GS aqui. E a versão mais recente do NodeJS. Tudo bem, agora vamos copiar isso. E então vamos
voltar ao código VS. E dentro do arquivo, você encontrará uma variável URI do
MongoDB. Vá em frente e cole
nosso URI lá. E então vamos alterar
a senha pela senha real
da nossa conta. Então, se você já tem
sua senha, pode colocá-la aqui. Se você não salvou a senha, você pode voltar ao MongoDB Atlas fechá-la
e acessar o banco de dados. Em seguida, clique em
Editar na sua conta e, em
seguida, clique em Editar senha. E aqui podemos
gerar uma nova senha
clicando no botão de geração automática de senha
segura. Então eu vou fazer isso. Vou copiar isso. E, em seguida, certifique-se de atualizar um usuário. E depois volte para o código VS. Vá em frente e, basicamente, digite a senha e salve o m5. Em seguida, vamos
abrir o terminal. E então vamos
instalar o Mongoose. Vamos executar o comando
PMPM e depois o mongoose. E porque estamos
usando isso, sim, vamos instalar o Mongoose. Este módulo nos
fornecerá um conjunto de decoradores e outras funções utilitárias
úteis para trabalhar com o MongoDB. Pressione Enter e
aguarde a instalação. Depois de instalarmos nossos
módulos, vamos
importá-los para nosso modelo adulto,
o arquivo ts, fecharemos o terminal
e aqui, esse é o M4. E então, dentro da matriz de
importações aqui, vamos importar o módulo
mongoose e usá-lo em nosso projeto chamando
o módulo mongoose dot for root. Então, vamos escrever o módulo quatro do
mongoose. E dentro desse método, vamos adicionar o URI do
MongoDB a partir do processo. Sublinhado do Mongo DB. Mas para ter
acesso ao império, precisamos usar o
serviço de configuração fornecido pelo nest. Sim, precisamos
instalá-lo primeiro. Então vá em frente e abra novamente
o lado do terminal aqui, use o npm e depois adicione. Isso diz Salvar para salvar
como uma dependência de desenvolvimento, o Nest CSF. Em seguida, modo de configuração. Pressione Enter, aguarde
a instalação. Tudo bem, quando a
instalação estiver concluída, podemos importar o módulo de configuração
dentro do módulo do aplicativo e
controlar seu comportamento, o método de quatro raízes. Então, vamos prosseguir
passo a passo e importar. Agora, vamos colocar
isso dentro da matriz. Vá em frente e adicione uma vírgula. E então aqui, à direita, configure o módulo four root. E esse método aceitará
um objeto de propriedades. A primeira propriedade é global. Essa propriedade fará com
que o módulo de configuração torne o arquivo m disponível
globalmente
dentro de nosso aplicativo. A segunda propriedade
é o caminho do arquivo. Agora, vamos adicionar o arquivo de
pontos assim. Então, acabei de adicionar o nome. Nesse caso, estamos nos referindo ao diretório raiz
do nosso projeto. E o modelo
de conflito
procurará esse arquivo dentro
do diretório raiz. Tudo bem, agora você pode adicionar vários arquivos
adicionando uma matriz. E então, se você não tem
int e outro arquivo int, como talvez, eu não
sei nada. Você pode adicioná-lo
dessa forma como uma matriz. Mas para nós, só
temos um arquivo, então vamos mantê-lo assim. Agora, como você pode ver, a classe modal de configuração
é uma ferramenta poderosa que nos permite acessar a variável de
ambiente
globalmente em nosso projeto. Usando o
módulo de configuração para o método de inicialização, podemos configurar facilmente o módulo para tornar as variáveis de
ambiente armazenadas no arquivo dot M acessíveis em todo
o aplicativo. Isso significa que não precisamos amplificar manualmente
o arquivo dot M em cada módulo ou componente que precisa de acesso
a essas variáveis. Em vez disso, podemos simplesmente
usar o serviço de configuração para acessar as variáveis
de ambiente de qualquer lugar em
nosso aplicativo. Isso facilita muito gerenciamento de nossa
configuração e
a manutenção um ambiente consistente em todas as partes do nosso aplicativo. Tudo bem, agora terminamos
de configurar o Mongoose e estamos prontos para começar a
trabalhar em nosso aplicativo. Então, no próximo vídeo, vamos criar
nosso esquema de blog. Além do esquema de pontos do blog, o arquivo ts usando o
Mongoose fez isso nos projetos anteriores, mas desta vez será um pouco diferente porque
estamos usando o nest. Sim. Então nos vemos lá.
4. Projetando e implementando o esquema de blogs: Neste vídeo, criaremos o esquema do blog em
nosso projeto nest yes. Começaremos abrindo o diretório de hemocomponentes e, em seguida, eles bloquearão o
esquema no arquivo ts. Dentro desse arquivo, vamos
começar exportando uma nova classe e chamando-a de bloqueada. Dentro dessa classe,
adicionaremos duas propriedades, título do tipo string e
conteúdo do tipo string. Agora temos algumas áreas
aqui vindas do ES e tudo o que você precisa fazer
é salvar o arquivo. Se os erros não
desaparecerem automaticamente, você pode ir para Arquivo e
preferências e depois para configurações
e pesquisar por ES lint. Role para baixo e
certifique-se de ativar o ES e como
formatador para seu VSCode. E, em seguida, role para cima
nas configurações de Jason. Em seguida, certifique-se de copiar todas essas linhas para
citar suas configurações, o arquivo adjacente
e fechar. Isso. Ainda não funcionou para você. Certifique-se de ter o LLF como a sequência de fim de linha.
Seu VS, VSCode. Você pode alterá-lo aqui, mas isso
voltará ao padrão como LLF quando você
reabrir o VSCode para obter. Portanto, para tornar isso permanente, você pode voltar às configurações e
pesquisar o fim da linha. Role para baixo e certifique-se de
escolher barra invertida n como caractere
de fim de linha. Em seguida, feche o teste
novamente no arquivo, se ele ainda tiver alguns erros, volte para o RRC mais bonito e
adicione o final da linha igual a L F. Agora, essas são todas as configurações
necessárias
para definir automaticamente
a opção Salvar com ES. E agora vamos
voltar ao nosso esquema. Portanto, essa é apenas uma classe
simples e ainda não
é um esquema mongoose. Para torná-lo um esquema mongoose, usaremos esse
decorador de esquema importado do T S Mongoose. Então vá em frente e importe o esquema da biblioteca
Nes Yes, mongoose. E vamos colocá-lo no topo
da nossa classe sanguínea. Assim. Garante que não haja linhas entre a classe
e o integrador. Agora, para identificar as duas propriedades como propriedades do
Mongoose, usaremos outro
decorador e importaremos do mesmo pacote. nome à sonda e
coloque-a no topo de cada propriedade. Para o título. Prepare-se para o conteúdo. Também podemos adicionar alguma
configuração à sua propriedade adicionando um objeto dentro do decorador da
propriedade. Então, por exemplo, se você quiser que o
título seja obrigatório, podemos adicionar um objeto e, em seguida, adicionar a propriedade necessária
e defini-la como verdadeira. O mesmo acontece com a propriedade do
conteúdo. Então, vou copiar esse
objeto e colá-lo aqui. Em seguida, salve para remover todos
os erros de Eastland. Agora, para exportar a
classe sanguínea como um esquema, importaremos a classe de
fábrica do esquema desta
biblioteca sim, última do mongoose aqui, certo? Esquema, fábrica. E outros, mas vou
exportar uma constante e chamá-la esquema de
log e defini-la
como fábrica de esquemas. Em seguida, crie um método de classe e
passaremos na classe sanguínea. Isso configurará
nosso esquema de blog. Agora, também precisamos exportar o tipo de documento do
blog
para esse arquivo. Para fazer isso, isso é importante. O documento hidratado diretamente
da embalagem Mongoose. E então, no topo,
vamos exportar
um tipo e nomeá-lo,
inserir um documento e defini-lo
como um documento hidratado. E passe o plugue. Finalmente, para tornar o esquema acessível em todo o
nosso aplicativo, precisamos acessar o módulo do aplicativo. Deixe-me primeiro dizer isso
e ir para o módulo de aplicativos. E então vamos usar o módulo Mongoose
dentro da matriz de importações,
assim, acordo com o Mongoose. E desta vez vamos
usar o método de recurso. E dentro dela
vamos passar uma matriz. E essa matriz
conterá modelos Mongoose. Embora seja um modelo Mongoose, é um objeto com duas propriedades. A primeira propriedade é nome. E podemos obter o nome
do curso de classe sanguínea. Você precisa importá-lo do blog,
blog, nome do ponto do esquema. E a segunda propriedade
é a propriedade do esquema. E vamos obter o
esquema do esquema do blog e nos certificar de
importá-lo também do
esquema do blog, o arquivo ts. Agora, o
método Mongo is model.fit é usado para importar modais
Mongoose em um módulo de
recursos específico no STS. Esse método usa duas
propriedades, nome e esquema. A propriedade name especifica
o nome do modelo que está sendo importado e geralmente é definida como o nome
da classe do modelo. A propriedade schema especifica o esquema Mongoose que corresponde ao
modelo que está sendo importado. Usando o
modelo Mongoose para o recurso Method. Tornamos nossos modelos Mongoose acessíveis dentro desse módulo. Agora, a razão pela qual tive que
importar o esquema do blog
aqui é porque o módulo do aplicativo em que ele tem
serviço de arquivos como módulo raiz
em seu ninho, sim. Projeto. Ele é responsável por
reunir todos os
diferentes componentes, controladores e fornecedores
que compõem seu aplicativo. Ao importar esses módulos
para o módulo do aplicativo, o arquivo ts, estamos
disponibilizando-os globalmente. Jogue fora seu aplicativo. Isso permite que você reutilize facilmente
componentes e fornecedores, tornando seu código mais organizado
e fácil de manter. Ao criar
um novo componente, é importante lembrar de
importá-lo para o módulo do aplicativo, o arquivo ts, para que ele possa ser usado por outras partes
do seu aplicativo. Da mesma forma, ao criar
um novo modelo do Mongoose, você também precisará
importá-lo para o módulo do aplicativo, o arquivo ts, para que possa ser usado por seus controladores
e provedores. Isso permite que você interaja
facilmente com seu banco de dados MongoDB e execute operações
como criar, ler, atualizar e
excluir documentos. Tudo bem, então isso
conclui esta lição. E na próxima, vamos nos
aprofundar no serviço de blog
que está em seu arquivo. É aqui que a verdadeira mágica acontece, pois usaremos
o modelo de blocos que acabamos criar para realizar várias operações
de
banco de dados, desde a leitura e
criação de postagens de blog Atualizá-las e excluí-las cobriria tudo
na próxima lição. Portanto, mantenha suas anotações à mão e prepare-se para codificar. Te vejo na próxima aula.
5. Criando o serviço de blog: Neste vídeo,
exploraremos o poder dos serviços no SES usando
a classe de serviço do blog, que já
foi configurada com o decorador injetável no arquivo
do bloco services.js. Então, antes de começarmos,
gostaria de lembrar que todas essas
configurações deste vídeo
já estão disponíveis
no projeto , passando para a seção de
recursos. Portanto, certifique-se de baixá-lo, abra-o em seu editor de
código preferido e execute o PMPM instalando o terminal para baixar todos os pacotes
necessários. Com isso resolvido, vamos mergulhar no mundo
dos serviços e do SES. Portanto, essa classe
será responsável
por gerenciar todas as nossas operações de
banco de dados. Isso significa recuperar, criar, atualizar e
excluir postagens do blog. Ao utilizar o decorador
injetável, podemos definir essa classe
como um serviço que pode ser facilmente reutilizado em toda a
nossa aplicação. Ao final deste vídeo, você terá uma
sólida compreensão de como os serviços funcionam no SES e como usá-los para
interagir com o banco de dados. Então, vamos começar. Agora, nas lições anteriores, discutimos
a importância
do decorador injetável no SDS. Esse decorador é usado para indicar que a
classe se destina a ser um serviço que pode ser injetado em
outros componentes. É um aspecto crucial
da escrita de
código limpo, modelador e sustentável no SDS. Usando o decorador
injetável, podemos gerenciar facilmente
dependências e superfícies de
cadeiras entre diferentes
partes de nossa aplicação. Portanto, não se esqueça de adicionar o decorador injetável antes de definir sua
classe de serviço no SDS. Com isso dito,
ele foi assinado para usar o poder do MongoDB
em nosso serviço. Para fazer isso, precisamos importar o decorador do modelo de injeção
de uma biblioteca SES mongoose. Esse decorador é usado para injetar um modelo Mongoose em
um serviço inicial, facilitando a execução operações
de banco de dados
no modelo. No nosso caso, queremos definir uma variável privada dentro do
construtor dessa classe. Vamos conectar o modal. E será do
tipo modelo Mongoose. Para fazer isso, precisamos importar a interface
do Moodle
do Mongoose. Essa interface é uma interface
genérica que aceita um documento
mongoose. Porém, no nosso caso,
vamos passar o documento de sangue importado
do blog, esse arquivo de esquema. Agora, essa variável
privada será injetada usando o decorador
modal de injeção. Assim, o avaliador
aceitará o nome do modelo do blog, poderá obtê-lo do nome da classe
do blog e se certificar de desdobrar o arquivo do esquema de
pontos do blog da classe do blog. Agora, com essa variável
injetável, poderemos realizar várias operações de banco de dados
em nosso blog Moodle e torná-la acessível
em todo o nosso serviço. Agora que temos nossa
conexão com o MongoDB começamos a criar alguns métodos para realizar operações
de banco de dados. Primeiro, criamos
o método create. Certifique-se de que seja assíncrono. Esse método será responsável
pela criação de novos bloqueios. Mas antes de começarmos a trabalhar
no método em si, é importante
observar os argumentos que o método o aceitará. Em vez de incluir
diretamente os argumentos, como : string de título, conteúdo, string. A melhor prática é criar objetos
de transferência de dados
ou interface DTO em outro arquivo separado que conterá os dados
que queremos salvar. Isso nos ajudará a manter a estrutura dos
dados e evitar quaisquer erros que possam surgir da transmissão de dados de
Anchorage para o método. Ou isso, você
encontrará como criar um DTO, o arquivo ts, salvar
a pasta de detalhes. Vamos
exportar esse arquivo e criar uma interface com o nome
create blog, the teal. Essa interface conterá as
propriedades que queremos salvar, o título do tipo string e
o conteúdo do tipo string. Salve esse arquivo e feche-o. Volte aqui, remova
o título e os argumentos do conteúdo e
substitua-os por um argumento, crie um blog, qualquer tipo. Crie o log D PARA
certificar-se de
importá-lo da pasta Tiers
e do arquivo DO do criador. Agora, dentro do método create, precisamos criar uma
instância de um modelo de blog. Então vá em frente e crie
uma constante de blog. Use a nova palavra-chave. E, em seguida, use essa palavra-chave
para acessar o modelo de sangue. E então vamos passar os detalhes de criação
do blog. Isso criará uma instância
do modelo de bloco. Então temos que salvar isso
e devolvê-lo ao cliente. Devolva um peso. Salve pontos do blog. Em seguida, criaremos outro método com
o nome update. Esse método será responsável pela atualização de uma postagem específica do blog. Primeiro, precisamos criar
o DTO do blog de atualização. Então vá em frente e abra as
atualizações são DTO, o arquivo ts. E aqui exporte
as atualizações da interface, feche o acordo. Agora, para atualizar
essa postagem específica do blog, o cliente precisa enviar o ID. Então, vamos esperar pelo ID de
sublinhado do tipo string. Como você sabe, o Mongo armazena o
ID com um sublinhado. Portanto, certifique-se de adicionar isso. Então, para o título
e o conteúdo, vamos recebê-los
dentro de um objeto de adereços do cliente. E o título aqui é do tipo string e também do
tipo de conteúdo string. Mas queremos dar ao cliente
a liberdade de atualizar
apenas o título ou apenas. Mas vamos tornar essas
propriedades opcionais adicionando o ponto de interrogação antes dos dois pontos na frente
de cada propriedade. Salve esse arquivo e feche-o. Aqui, salve o método de atualização. Vamos adicionar ao
blog de atualização esse argumento TO. Será do tipo
atualizar um vídeo de vlog. Certifique-se de importar isso
do arquivo de vídeo atualizado. Agora salve o método de atualização. Vamos usar o
método
find one e update da biblioteca mongoose para atualizar a
postagem do blog no banco de dados. Então, vamos
devolver um peso, esse modelo de blog de
pontos, encontrar um e atualizar. Agora, neste método, primeiro
aceitaremos um objeto
como uma consulta de filtro. Esse objeto filtrará o documento do blog com
o ID sublinhado. E podemos obter isso
no blog de atualização DTO dots. E o risco de identificação. O segundo argumento será
o documento atualizado
ou a consulta de atualização. É claro que você pode obter
isso das atualizações do blog dto dot client prompts. O último argumento será um objeto com uma nova
propriedade definida como verdadeira. A nova propriedade
informará o método de
localização e atualização para retornar o documento de dados
em vez do documento antigo. Em seguida, vamos criar
um método assíncrono, e eles podem obter um. Esse método usará o ID da postagem do blog como um
argumento do tipo string. E ele retornará a postagem do blog
correspondente
do banco de dados. Então, aqui dentro, certo,
volte, oh espere. Neste modal de bloco, encontre um. Esse método
aceitará um objeto. E dentro dela,
vamos consultar nossa postagem no blog com
o ID sublinhado. Deve ser igual
ao ID do argumento. O próximo método
será bom. Ah, e
será responsável por
retornar as postagens do blog e o banco de dados. Agora, esse método não
aceitará nenhum argumento. E, em vez disso, ele retornará
imediatamente 08. Este modelo de registro de pontos. O método Find by ID precisa aceitar um objeto vazio para retornar todas as
postagens do blog e o banco de dados. E, finalmente, vamos
criar o método delete one. Esse método usará
o ID da postagem do blog como um argumento do tipo
string e excluirá a postagem do blog correspondente
do banco de dados usando o método find
one e remove. Vá em frente e devolva um peso, esse modal sanguíneo que é 0,1. E remova e remova o documento do blog com o ID sublinhado igual
ao ID do argumento. Agora vamos definir o tipo de
retorno de cada método. O método create é
uma promessa que
resolverá um documento ou bloco
de título. Para o método de atualização. A mesma coisa. Promessa. Isso resolverá o documento do
blog aqui. A mesma coisa também. Promessa. Plugue para obter. Tudo. Essa será uma promessa que resolverá
uma série de blocos. Para a exclusão,
enviaremos de volta um número ou um booleano. Você pode definir isso como um tipo de resolução para esse método ou
deixá-lo vazio. Então, vamos salvar esse arquivo e
pronto para este vídeo. Com esses métodos, agora temos servidores funcionais que podem realizar todas as operações de
banco de dados necessárias, mas farei o upload do componente. No próximo vídeo. Usaremos esse serviço e
o controlador do blog para definir os endpoints de nossa API. Portanto, fique atento.
6. Criando o controlador de blog 1/2: Bem vindo de volta. Até agora, criamos
com sucesso
nosso hemocomponente, que inclui o
esquema do blog e o Serviço de Sangue. Agora é hora de trabalhar
no controlador do blog. Você encontrará o ponto de
partida do projeto na seção de
recursos de vídeo. Para começar, basta
baixar o projeto e abri-lo em seu editor
VSCode. E antes de começar a codificar, certifique-se de executar o PMPM instalado
no terminal para instalar todas
as dependências necessárias. Neste vídeo,
criaremos o arquivo blog dot
controller.js, que funcionará como
a ponte entre o front-end e
o
back-end de nosso aplicativo Usaremos esse arquivo para definir
os vários endpoints do nosso componente de blog
e também será
integrado ao nosso serviço de blog para
realizar operações de banco de dados. Então, vamos começar. Nosso próximo passo é mergulhar
no mundo das uvas. Especificamente, daremos
uma olhada no decorador do
controlador. Esse decorador nos
permitirá tornar o controlador do blog acessível a
partir do roteador do RBI. No entanto, se quisermos
mudar o roteador
da raiz para, por exemplo, blog. Assim. Podemos simplesmente passar
o blog de strings para o controle ou para um decorador. Dessa forma,
poderemos controlar o caminho em que nosso
controlador de blog está acessível. Na próxima etapa, precisamos importar
nosso serviço de blog para usar todos os métodos de banco de dados que criamos na última lição. Para fazer isso, adicionaremos a declaração de importação na
parte superior desse arquivo e importaremos o Blood Service do blog que atende o arquivo ts dentro
do controlador de bloco. Vamos criar o construtor e definir uma variável
chamada blogs. O serviço definirá seu tipo
para conectar a classe de serviço. Dessa forma, o TypeScript
pode entender as propriedades e os métodos disponíveis
no serviço de blog. Isso torna nosso código
mais fácil de escrever, manter e livre de erros que
ocorreriam em tempo de execução. Também ajuda no preenchimento
do código, permitindo que escrevamos código com
rapidez e precisão. Agora vamos criar
o Create Router. Primeiro, adicionaremos um nome de
método assíncrono e criaremos. Mas apenas com esse método criar um roteador
real funciona. Precisamos decidir que tipo de solicitação esse
roteador tratará. No nosso caso, queremos enviar as informações do blog
do cliente para o servidor. Então, implementaremos
uma solicitação de postagem. Podemos fazer isso facilmente com
a decoradora de postes que pode ser importada do ninho em
que ela veio na embalagem. Então vá em frente e faça isso e coloque-o no topo do método
create, assim. Agora, a maioria dos decoradores pode aceitar um argumento de
string opcional que representa o
caminho do roteador em que eles criam. O roteador
aceitará solicitações. Se deixarmos em branco, o cliente enviará a solicitação ao
host local do bloco 3.000. No entanto, se vamos
adicionar vários roteadores, é melhor tornar o
Create Router acessível por meio da criação do caminho do roteador. Então, vamos fazer isso. Agora, o método create
receberá um argumento corporal. O argumento
do corpo será do tipo create log detail. Certifique-se de importar a interface IO
do criador TO by. Agora, adicionar o argumento body dentro do nosso método create não é suficiente porque precisamos fazer uma conexão entre o corpo da
solicitação e esse argumento. É aí que entra o
decorador de carrocerias da Nes Yes, come in, importe-o primeiro de uma bagagem de
chegada da SES. E vamos colocá-lo
dentro da lista
de argumentos do nosso método create antes
do argumento body, assim. E agora, finalmente, podemos usar
o serviço de blog para criar o documento do blog e
devolvê-lo ao lado do cliente aqui. Retorne uma lista de espera, blog de
pontos, serviço, criação. E então vamos passar o argumento body para
o método create. Quando salvamos o arquivo ou
as áreas desaparecerão. Porque o argumento body
tem o mesmo tipo do argumento DTO create blog
do método create. E com isso, concluímos a configuração do Create Router
em nosso controlador de blog. Parabéns. No próximo vídeo,
continuaremos trabalhando com o controlador do
blog e implementaremos o restante
dos roteadores,
como atualizar, excluir e obter. Isso nos permitirá realizar todas as operações necessárias em nossos documentos
de blog, além de abordar como lidar com erros
que possam ocorrer durante essas operações e garantir nosso aplicativo seja
robusto e confiável. Então, fique ligado no próximo vídeo e vamos continuar
construindo juntos.
7. Criando o controlador de blog 2/2: Ótimo trabalho em chegar até
aqui. Na aula. Neste próximo segmento, vamos dar
uma olhada no restante da classe
de controladores de bloco. Vamos começar criando
a atualização Troutman. Primeiro, criaremos um método
assíncrono com o nome da data. Esse método incluirá
um argumento corporal. Então vá em frente e use o decorador de corpo crie o argumento do corpo e
forneça o tipo de atualização. vlog de vídeo e certifique-se de
importá-lo do arquivo de vídeo. Agora, esse método receberá
uma solicitação de postagem. Então, vamos usar o integrador de postagens e atualizá-lo com o caminho. Além desse método, vou chamar o método de atualização
no serviço de blog. Então vá em frente e retorne 08. Esse serviço que atualiza e
transmite o argumento do corpo. Agora, esse método de atualização atualizará o
documento do blog no banco de dados. Vamos passar para
o roteador get one. Vá em frente e crie um método
assíncrono novamente, e eles poderão obter um. Esse método nos permitirá
recuperar uma única
postagem de blog do banco de dados. E ele aceitará um
argumento de ID do tipo string. Esse id será passado como um parâmetro para
o caminho do roteador, que será definido usando
o decorador get. Então vá em frente e importe
o pacote comum get degraded do nest yes slash
common. E então, aqui dentro,
vamos dar a ele um caminho de identificação pós-barra. E então, dentro da
lista de argumentos desse método, vamos usar
outro decorador para extrair o ID do caminho
do roteador. Este é o maior
se chama para. Então vá em frente e importe isso
também do pacote mesial
é comum. Então, dentro dele, temos que nomear nosso parlamento ou, no
nosso caso, nosso parâmetro tem o nome id. Agora, usaremos esse
método para chamar o método getline
no serviço do blog. Então vá em frente e devolva
esse serviço de bloqueio. Obtenha um e passe
o argumento ID. Isso recuperará a postagem de
blog desejada do banco de dados. Em seguida, criaremos
o Get ou roteador. Esse método nos permitirá
recuperar todos os cães, oh, é do banco de dados. Primeiro, criaremos, novamente, um método assíncrono
com o nome gets. Tudo. Esse método não
aceitará nenhum argumento pois simplesmente recuperará
todas as postagens do banco definirá o caminho do
roteador usando o decorador get
seguido pelo caminho. Por fim, usaremos
esse método para chamar o método get
do serviço de bloqueio. Então vá em frente e retorne 08. Esse serviço de bloqueio, serviço que obtém tudo isso recuperará todas as
postagens do blog do banco de dados. Agora, por último, mas não menos importante, criaremos o roteador
intercalado. Esse método nos
permitirá excluir uma única postagem
do blog do banco de dados. Primeiro, criaremos um método
assíncrono e o chamaremos de delete. Esse método
aceitará um ID como argumento do tipo string. Esse id será passado como um parâmetro no caminho
do roteador, que definirá usando a
exclusão da cratera na parte superior. Importe e use o decorador
Delete, seguido pelo caminho delete large dois-pontos ID para obter o ID
da postagem do blog desejada. E então vamos
usar o paran, quanto maior, para extrair
o ID da solicitação. Agora, usaremos esse
método para chamar o método delete
no serviço de blog. Então, retorne, aguarde esse serviço de
bloqueio que exclui um e passa
o argumento ID. Isso excluirá a postagem de
blog desejada do banco de dados. E com esse método final, agora
concluímos a classe de controladores de
sangue e todos os seus roteadores. Ótimo trabalho em acompanhar e implementar essas
partes importantes do nosso projeto. A propósito, o
argumento ID não precisa ser exato. Semelhante ao nome do parâmetro? Sim, pode ser qualquer coisa
como, por exemplo, ID sublinhado. Sim. E aqui você tem
que mudar isso para ID sublinhado. Mas o parâmetro dentro do caminho do
roteador deve ser igual ao parâmetro do nome
do parâmetro dentro
do decorador do programa. Caso contrário, você não conseguirá
obter o id do pacote do
roteador. Ok, agora que
terminamos de criar todos os roteadores para o controlador do
nosso blog, é importante
pensar no tratamento de erros. Afinal, as coisas podem dar
errado em qualquer aplicativo. E é fundamental lidar com essas situações de forma adequada
e profissional. No SDS, temos várias
maneiras de lidar com erros, incluindo o uso de filtros de
exceção, vibrações e proteções. Nesta lição,
usaremos filtros de exceção para lidar com erros em nossos métodos ou controle de
sangue. Primeiro, vamos testar a classe
de exceção
HTTP do pacote ***** yes,
coming. Portanto, na principal exceção
HTTP de importação, essa classe nos permite lançar uma
exceção relacionada a http e enviar um código de status específico e uma mensagem de
erro ao cliente. Em seguida, vamos executar nosso código
dentro de um bloco try catch e por meio de uma exceção HTTP
dentro do gráfico de guts, por exemplo, dentro do método create. Podemos fazer algo
assim. Experimente. Então aqui, pegue. E vamos pegar o erro. Em seguida, pegue essa linha e
coloque-a dentro do bloco de teste. E caso tenhamos outras que
vamos usar ou
vamos lançar uma
nova exceção HTTP. E a classe de exceção HTTP aceitará um argumento de mensagem. Então, essas reuniões podem ser qualquer coisa. Portanto, em nosso caso, não
sabemos o que deu errado
nos servidores de log. Crie esse método de criação. Então, vamos enviar algo parecido quando estiver no porta-malas. E então temos que apresentar
outra discussão. Esse argumento será
o código de status HTTP. E podemos obter isso
de outra classe com o nome http status. Certifique-se de importá-lo também. Vem de um SDS. Essa classe tem
muitos outros tipos. E o que
vamos escolher aqui é o automático interno. Salve isso para remover todos os erros de
sim - e como você pode ver, tratamento
de erros no SES é muito mais simples do que um aplicativo
NodeJS puro. Podemos implementar
esse mesmo padrão no restante dos métodos. Detectar os erros e enviar uma mensagem de erro e um código de
status adequados para o cliente. Ao implementar o
tratamento de erros dessa forma, garantimos que nosso
aplicativo
se comportará adequadamente, mesmo no caso de outros fornecerem uma
melhor experiência ao usuário e manterem nosso código
organizado e profissional. E agora é isso
para este vídeo. Agora concluímos a classe de controlador do
blog e todos os seus roteadores encontrarão o resultado final
desta videoaula anexado
à seção de recursos. Então vá em frente e faça o download
caso algo
dê errado em seu código. No próximo vídeo,
vamos testar nosso aplicativo usando
o software carteiro. Então nos vemos lá.
8. Teste o componente de blog com carteiro: Nesta lição, testaremos nossos componentes sanguíneos usando
o software Boltzmann. Antes de começarmos o teste, vamos ter
certeza de que estou colocando o controlador azul
e o serviço de blog dentro do aplicativo modelado
no arquivo ts para fazer isso. Primeiro, abra o App Model e depois dentro da matriz
de controladores. Vamos adicionar o controlador de sangue. Claro que você
precisa importar isso do arquivo blog dot
controller.js. Para o serviço. Vamos colocar isso dentro da matriz
de provedores. Então vá em frente e escreva
um serviço de blog e importe-o também do arquivo correspondente. Agora, isso é importante para garantir que o
componente esteja totalmente integrado ao nosso aplicativo e possa ser acessado
pelo correio. Agora, antes de executarmos
nosso aplicativo, precisamos nos certificar de importar o arquivo antes de tudo. Então vá em frente e coloque essa linha como o primeiro item da matriz. Porque se você não fizer isso, você receberá um erro no banco de dados. Tudo bem, vamos salvar
esse arquivo e fechá-lo. Em seguida, abra o terminal aqui e execute o comando npm
run, comece a chamar diff. Tudo bem, como você pode ver
como um aplicativo SES está sendo executado e aguardando
conexões na porta 3.000. Agora vamos abrir nossos carteiros e criar
um novo espaço de trabalho. E então aqui dentro
da seção de coleção, clique no botão Novo e
escolha Solicitação HTTP. Agora vamos começar a
testar o Create Router. Faça isso. Vamos escolher a
solicitação de postagem dessa lista. Aqui, vamos passar o URL
http localhost e, em
seguida, o caminho
do roteador do método create. Portanto, o método de grade existe
dentro do blog Create. Agora, na seção
do corpo da solicitação, enviaremos
uma carga JSON que representa a
postagem do blog que queremos criar. Você faz isso, clique na linha. E então aqui, mude dx2, json. E então vamos criar um objeto aqui e
passar o título. Então, o título será
blogado ou blog de teste. E o conteúdo será
um conteúdo de teste. Agora, para enviar essa solicitação,
clique no botão Enviar. Agora, como você pode ver, recebemos uma resposta
com o status 200 e o objeto adjacente representando a
postagem recém-criada no blog com o id, o título, o conteúdo
e o sublinhado. O sublinhado V representa a
versão deste documento. Agora vamos usar o ID
desse documento de bloco
nos próximos roteadores. Então, vamos
copiar esse ID. E vamos salvá-lo como uma variável de ambiente
dentro do Postman. Então, clique na seção de
ambientes. E então aqui dentro, vamos nomear este
blog como ID de sublinhado. E vou definir o valor
para o ID do documento do blog. Vamos clicar no botão Salvar para salvar essa variável de
ambiente. Então vamos voltar aqui. E vamos
comprar um roteador. Este roteador recupera uma
única postagem de blog com base em seu ID para que esse roteador
envie uma solicitação get. Então, vamos mudar isso para obter. E depois vamos enviar uma solicitação
para o path Blog e depois postar. E então enviaremos
o ID que
acabamos de salvar, pois um
ambiente global está no Postman para
acessar essa
variável de ambiente para
chaves como essa. Em seguida, 2s bloqueiam o ID de sublinhado. Não precisamos enviar nenhum corpo. Então vá em frente e escolha nenhum aqui e, em seguida, envie a solicitação. E aqui está, temos
nosso documento de blog convidado. Agora, vamos
testar o roteador get all. Este roteador ou recupera todas as postagens do blog
armazenadas em nosso banco de dados. Atualmente, temos uma postagem no blog. Então, vamos
obter uma matriz de
um documento de blog
que tem esse roteador. Certifique-se de que você tenha o tipo de solicitação de
gato aqui. E depois altere esse URL também. Blog, depois 0, envie a solicitação e você deverá obter uma matriz de
um documento de blog. Mas, como você pode ver aqui,
tenho vários documentos de blog porque testei isso
antes de começar a gravar. Então, eu tenho várias postagens de
blog aqui. Mas, como você pode ver, também temos nosso último documento em bloco, representado dentro dessa matriz. Portanto, no seu caso, você obterá apenas esse documento em bloco. Agora, finalmente, vamos
testar o roteador de exclusão. Esse roteador ou exclui uma única postagem do blog
com base em seu ID. Então, quando enviamos a solicitação, eu obteria uma matriz
de todos esses argumentos registrados. E esse documento do blog
não estará lá. Ele será excluído. Para você. Você
receberá uma matriz vazia. Vamos testar
esse blog e depois excluir. Dentro. Vamos adicionar o ID do nosso blog, duas chaves e, em seguida,
selecionar bloquear ID de sublinhado. Certifique-se de alterar o tipo de
solicitação a ser excluída. Vamos enviar isso. E aqui vamos nós. Na verdade, recebemos o documento do blog excluído. Sim, não recebemos o
site ou o aplicativo. Não enviamos de volta uma
série de documentos. Então, aqui, o deletar. Esse método
retornará apenas o documento do blog e retornará um valor nulo
se não encontrar o documento
solicitado. Sim, vamos voltar
aqui e testar novamente o roteador
get all e verificar se esse documento de bloqueio foi
realmente excluído ou não. Vamos mover isso. Em vez disso, vamos chamar o blog de slash bowl e mudar seu valor bruto para obter
do que ascendentes. E, como você pode ver, o registro de teste não
é tão n dentro dessa matriz. Então, foi realmente excluído. isso, testamos todos os roteadores e o controlador do blog
usando
o software postmen, enviando solicitações
HTTP e inspecionando as respostas do servidor Podemos ter certeza de que nosso componente está
funcionando conforme o esperado. Portanto, certifique-se de importar o controlador
e os servidores de blocos aqui. E colocar esse salto de
lombada ou o arquivo M como o primeiro
item da matriz. No próximo vídeo,
começaremos a trabalhar no componente do usuário. Então, cílios.
9. Projetando e implementando o esquema de usuário: Na próxima lição, vamos nos concentrar na
criação do esquema do usuário. O esquema do usuário
será usado para armazenar as informações dos
usuários registrados em nosso aplicativo. Para começar com on, basta adicionar a propriedade de e-mail como
uma propriedade do esquema. Isso simplificará o processo de assinatura para nossos usuários. Agora, quero
desafiá-lo a tentar criar o esquema do usuário sozinho
antes de assistir a este vídeo. Isso ajudará você a
entender o processo de
criação do seu esquema e
a lógica por trás dele. E depois de experimentar, qual é o vídeo para ver esse processo
passo a passo
e criar o esquema do usuário e
acompanhar para evitar erros. Agora vamos começar dentro do esquema de pontos do usuário,
o arquivo ts. Vá em frente e exporte uma nova
classe e nomeie-a como lado do usuário. Essa classe terá uma
propriedade inata do tipo string. Agora vamos importar esses
avaliadores esquemáticos e
extrair esquema desse pacote
sim do Mongoose. Em seguida, coloque-o no
topo da classe de usuário. Assim. Então, para o e-mail,
você precisa do suporte, da niveladora. Então, importe-o e coloque-o no topo da propriedade
do e-mail. Essa propriedade
será necessária. Então vá em frente e adicione a propriedade necessária
dentro do decorador de adereços. E então vamos
exportar nosso esquema de usuário. Vamos fazer isso com o botão. Crie um esquema de usuário com
nome constante e defina-o como igual ao esquema. Bactérias, certifique-se de importar isso desse sim, fungo. Em seguida, use o método create for class e passe
na classe user. Agora, a última etapa é
explorar um
tipo de documento do usuário a partir desse arquivo. Para fazer isso, esse é o tipo de exportação
e nomeie-o como documento do usuário. Em seguida, use o documento
hidratado e
retire-o da embalagem do Mongoose. Vamos usar esse tipo
para criar um
documento mongoose do tipo user. Agora vamos salvar esse arquivo
e ir para o módulo app, o arquivo ts aqui, e adicionar nosso modelo
Mongoose recém-criado dentro do módulo mongoose dot for feature method
dentro dessa matriz. Aqui, crie outro objeto, m mais n, O nome. Desta vez,
o nome será extraído da classe de usuário. Portanto, certifique-se de desdobrar
isso do esquema do usuário e, em seguida, passar o nome. E precisamos que o esquema
seja definido como esquema do usuário. Certifique-se de importá-lo também do
esquema de pontos do usuário, o arquivo ts. Deixe-me salvar esse arquivo agora. E, como você pode ver, não
há
nada complicado em criar um
esquema mongoose usando o SDS. Fizemos isso
nas lições anteriores e
fizemos isso novamente aqui. Espero que você tenha
conseguido criar
o esquema do usuário usando seu, oh, agora é isso
para este vídeo. Eu quero ser breve. E no próximo
vídeo,
começaremos a trabalhar no serviço
ao usuário. O serviço de usuário
conterá apenas um método ou create, mas vamos lidar
com a autenticação usando tokens JWT ou
JSON Web Tokens. Portanto, fique atento e
até a próxima aula.
10. Criando o serviço de usuário: Nesta próxima lição, mergulharemos na criação de um serviço
ao usuário e
nos concentraremos em criar apenas
o método de criação a partir de agora. Mas você deve se sentir
confiante em suas habilidades para continuar desenvolvendo os outros
métodos após esta aula. Agora, para se desafiar, você pode tentar criar
o método de criação
sozinho antes de
assistir ao vídeo. Ao fazer isso, você pode
reforçar o que
aprendeu e aplicá-lo
a um novo cenário. E você pode ir além
disso e tentar,
ao criar o método create, tentar enviar de volta um token
JWT para o usuário. Essa será uma ótima
oportunidade para fortalecer sua compreensão sobre a
criação de serviços e SCS. Portanto, prepare-se para
arregaçar as mangas e mergulhar na
criação do serviço ao usuário. Vamos começar criando nosso construtor dentro do serviço
ao usuário. Dentro dela, vamos
injetar o modelo do usuário. Então, para fazer isso, primeiro, vamos criar uma
variável privada e chamá-la de
modelo de usuário e fornecer a ela o
tipo de modelo importado do pacote Mongoose e
passar o documento do usuário como guia de documento do
Mongoose para isso, bem como do esquema de
pontos do usuário, o arquivo ts. Agora, definir o modelo de
usuário dessa forma não significa que o
injetamos em nosso serviço de usuário. Então, para fazer isso, usaremos o decorador e
verificaremos o Moodle. Importe isso dos
nazistas Slash Mongoose. Este decorador
aceitará o nome do modelo. Podemos obter isso do nome
da classe do usuário. Certifique-se de importar
a classe
de usuário do
esquema de aparência do usuário, o arquivo ts. Agora, com isso,
injetamos com sucesso o modelo do usuário em
nosso serviço de usuário. Agora podemos usá-lo dentro
do método create. Portanto, será um
método assíncrono com o nome create. E esse método aceitará um e-mail do tipo
string como argumento. E dentro disso,
vamos criar uma nova instância do documento
do usuário. Para fazer isso, usaremos a
nova palavra-chave e, em seguida, usaremos a classe UserModel na qual a
injetamos que usará seu
serviço para criar uma nova instância de documento de usuário passando um objeto
com a propriedade email. Agora, vamos salvar nosso documento do usuário
usando o método save. Mas desta vez
vamos manter o documento seguro dentro de uma
constante chamada usuário salvo. Então, oh, espere, por
esses métodos seguros. Agora, a razão pela qual
criei essa
constante de usuário salva aqui é porque vamos usar os dados
do documento do usuário para gerar um JSON Web Token , salvar os
dados do usuário dentro dele e depois enviá-los de
volta ao cliente. Então, na próxima linha, retornaremos um objeto
com a propriedade Jason ou token JWT. Essa propriedade conterá
a string do token web JSON. Agora, para fazer isso, para gerar o token
web JSON, será necessário
entender o que é um
JSON Web Token. Simplificando, um JSON
Web Token é uma forma transmitir
informações com
segurança entre partes como objeto adjacente. Nesse caso, as
informações seriam um token de autenticação
que identifica o usuário. Depois que um usuário fizer
login em nosso aplicativo, retornaremos um objeto
que contém o token JWT. Agora, esse token
será usado para autorizar o usuário a acessar rotas
protegidas. Mas, por enquanto, vamos nos concentrar em gerar o token JWT real. E para isso, precisamos
instalar algumas novas dependências. Então abra seu terminal. Aqui. Vamos executar o comando PMPM. Isso economiza. Em seguida, adicione ness G, S mais T W T. Este pacote é um pacote
utilitário que nos
ajuda na manipulação de GW t. O segundo pacote
serão
os pacotes JWT para passaportes. Agora, esse balde é
o pacote de passaportes que implementa
a estratégia da JWT. Vamos usá-lo quando
começarmos a proteger nossas rotas,
usando proteções de autenticação para impedir que
usuários não autorizados usem nosso PR. Agora, execute esse comando
e você deverá instalar
essas duas dependências
dentro do seu aplicativo. E depois disso, você
precisa instalar os tipos TypeScript do
pacote que o passaporte faz JWT e certificar-se de
instalá-los como uma dependência do desenvolvedor, usando a mesa
salva como tag div
e, em seguida, adicionar tipos, passaporte, isso é T W T. E aperte enter e conclua o processo de
instalação. Depois de
instalar essas dependências em
seu aplicativo, vá em frente e abra
o módulo do aplicativo, o arquivo ts ao lado aqui, e vamos importar
nosso módulo JWT para nosso módulo JWT que ele possa ser usado em todo o
nosso aplicativo. Para fazer isso, primeiro
importaremos o módulo JWT dos pacotes no
Nest GS slash JWT. E então, dentro
da pesquisa de importação, vamos usar
o módulo JWT. Em seguida, resistor. Aqui, vamos passar um objeto com algumas
configurações. Agora, a primeira propriedade dentro desse objeto
de configuração será o segredo. Aqui, salvaremos nosso token secreto
JWT. Agora, o token secreto
é usado para descriptografar o token JWT e extrair
dele os dados do usuário. Portanto, o token secreto JWT desempenha um papel crucial no processo de
autenticação. Portanto, temos que salvar esse
token dentro do arquivo m. Então vá em frente e abra isso. E você descobrirá que um segredo de
sublinhados do JWT é valioso. Você pode colocar aqui qualquer caractere
aleatório. E depois salve esse arquivo. Volte aqui. E vamos
usar essa variável de ambiente do
processo em que o objeto é secretado e,
em seguida, pontilhe DWT abaixo do
sublinhado. A segunda propriedade serão
os leilões de placas. Essa propriedade será um objeto com algumas outras propriedades
de configuração. Uma dessas propriedades é
a propriedade que expira. Isso definirá o
período em que o
token web JSON será válido. Ou, em outras palavras, definir o período em
que o usuário será autenticado em nosso
aplicativo e quando ele deverá fazer login novamente para obter
um novo JSON Web Token. Então, vamos definir
isso para dois dias. Em seguida, salve o módulo
do aplicativo, feche-o e feche-o. Além disso,
vamos gerar o token web JSON usando a superfície JWT que
vem da biblioteca SES slash DWT. Primeiro, é importante
na parte superior do nosso arquivo. E dentro do construtor
do serviço de usuário, vamos criar uma nova variável, nome e serviço GW t e
definir seu tipo como serviço JWT. Agora, volte para nosso JWT e nossa
propriedade e vamos usar esse serviço para assinar um novo token web JSON com
os dados de segurança do usuário. Portanto, o mesmo método
aceitará uma carga útil que pode conter todas
as propriedades que você
deseja salvar sobre o usuário
dentro do token web JSON. Então, no nosso caso, queremos salvar o ID do usuário. Podemos obter isso da constante de
usuário salva , esse ID de
sublinhado. E como o
id de sublinhado é do tipo Mongoose ID, precisamos alterá-lo para uma string usando o método
toString. Agora, a próxima propriedade
que eu queria salvar é o e-mail. podemos obter isso
dos usuários salvos ou da constante constante do usuário de segurança. Com esta peça final, concluímos com sucesso nosso serviço ao usuário. No próximo vídeo,
vamos criar nosso controlador de usuário e
criar o Create Router. Então nos vemos lá.
11. Criando o controlador de usuário: Bem-vindo a este vídeo em que nos
concentraremos na construção do controlador de usuário
em nosso aplicativo SES. Nas lições anteriores, criamos o
esquema do usuário e o serviço do usuário, que agora servirão como base para
o controlador do usuário. O controlador do usuário
seria responsável por lidar com solicitações HTTP
recebidas
e
direcioná-las para o método
de serviço apropriado para processamento. Agora, basta começar, vamos adicionar o usuário da string dentro
do controle ou decorador. Isso nos permitirá
criar um endpoint específico
para o controlador do usuário. Ao usar o decorador do
controlador, estamos definindo a rota base
para nosso controlador de usuário, o que nos
permitirá gerenciar
e organizar facilmente nossos endpoints de API. Agora, vamos adicionar a variável de serviço do usuário
dentro do construtor. Então, crie uma variável privada,
chame-a de Serviço de Usuário e defina seu tipo como classe de serviço
do usuário. Em seguida, vamos criar um método assíncrono,
chame-o de create. Esse método
aceitará uma solicitação de postagem. Então, importe e use o decorador de postagem na parte superior do nosso método create e, dentro dele, forneça o caminho create. Agora, esse método ou
esse roteador aceitará um corpo. E podemos extrair o corpo
usando o corpo maior. Então vá em frente e
importe-o também do pacote ninho, sim,
comum. E vamos definir
nosso argumento corporal. Portanto, nosso argumento corporal será um objeto que contém uma
propriedade de e-mail do tipo string. Agora, aqui vamos
retornar 08, esse serviço de usuário. E vamos usar
o método create dentro do serviço
do usuário para criar
um novo documento do usuário, salvá-lo no banco de dados
e depois retornar. O token JWT
entrará no Bus no e-mail
que está dentro do corpo. E com isso, criamos
com sucesso o controlador de usuário
e o Create Router. Assim, o usuário
poderá criar uma nova conta usando
o endpoint de criação. E então
vamos enviar de volta um token JWT para autorizá-lo. Enviar apenas o token
JWT não significa que nosso
aplicativo esteja totalmente protegido contra uso malicioso. É importante
lembrar que mais medidas precisam ser tomadas
para proteger nosso aplicativo. Dito isso,
no próximo vídeo, exploraremos como
podemos proteger nosso controlador
de blog contra usuários não autorizados
usando um JWT of God, que atua como um middleware de
autenticação. Com essa implementação,
podemos garantir que somente usuários autorizados possam acessar nossos endpoints e proteger nosso aplicativo
contra uso malicioso. Então, vamos manter esse vídeo curto e
nos vemos no próximo.
12. Implementando autenticação com guardas de auth: Nesta lição,
aprenderemos como
implementar a estratégia JWT
e, honestamente, a obrigação e proteger
nosso controlador de usuários
não autorizados é
usar um JWT desprevenido. Mas antes de nos aprofundarmos
na implementação, vamos fazer uma rápida
introdução sobre
cartões no SES sobre DSTs e contextos de
execução que são
adicionados como um middleware e verifica se uma solicitação está autorizada a acessar um
determinado ponto final. Portanto, usando esse jardim, poderemos verificar
se o token JWT é válido ou não e extrair dele a carga útil do
usuário. Agora que temos uma
compreensão básica das placas JWT, precisamos começar
instalando uma nova dependência. Então vá em frente e abra seu
terminal e execute o comando PMPM, salve vidas, passaporte. Este é um
pacote muito importante, pois será responsável por extrair o token JWT
do cabeçalho e decodificá-lo. E então, se for apenas datado
e nos fornecer os dados que foram
salvos dentro dele. Depois de terminar de instalar
o pacote de passaporte, feche
o terminal e seguida, certifique-se de baixar o ponto
de partida deste projeto que está anexado à seção
de
recursos deste vídeo em seu sistema. E então, dentro da
pasta Earth, você encontrará dois arquivos. Neste momento,
vamos trabalhar
na estratégia GWP, o arquivo ts. Aqui, vamos
exportar uma classe com um nome de estratégia JWT. E essa classe será injetável. E como podemos
torná-lo injetável, é
claro, com o decorador
injetável. Então vá em frente e adicione o W, essa classe ou o decorador
injetável e importado de um comentário de barra do
SES. Então, esta aula ampliará
a estratégia de passaporte da classe. Como eu disse, pacote de senha
inicial será responsável por
extrair o token JWT
do cabeçalho e decodificá-lo
e, em seguida, nos fornecer os dados que foram decodificados
do token JWT. Agora, essa classe
aceitará outra classe utilitária
com o nome strategy. Podemos importar isso
do passaporte dash d, t. Agora vamos criar o construtor dessa classe. E dentro dos colchetes encaracolados, vamos usar
o método super. Agora, o método super
é usado para chamar o construtor
da classe mãe. Bom dia, dentro do
construtor da subclasse, que é a estratégia do JWT, estamos permitindo que ela herde as propriedades e métodos
da classe principal, que é a estratégia do passaporte. Isso ajuda a criar um código
mais organizado e
sustentável. Sempre que você estende
outra classe, você precisa usar o
supermétodo para garantir que sua subclasse esteja herdando todas as propriedades e métodos
da classe principal. Portanto, esse método
aceitará um objeto, e esse objeto adicionará algumas propriedades. A primeira propriedade
é a solicitação do JWT. Essa propriedade dirá
à classe de senha como ele pode extrair o
token JWT da solicitação. Queremos extrair o token do cabeçalho como uma
barreira ou um token. Para fazer isso, vamos usar outra classe com
o nome extract JWT importado do traço de
senha g, DWT. Então, essa classe
nos fornece um método com o nome do cabeçalho
como token de barreira. Com esse método,
nossa classe de Esports, que
extrairá o token
do cabeçalho como um token de barreira. Agora, o segundo argumento
será
ignorar a exploração
e defini-la como falsa. Estamos transformando a melhor classe
de tabuleiro para não ignorar o token expirado. Portanto, se o usuário enviou um
token expirado para a API, rejeitará sua solicitação e enviará de volta
uma resposta em uma garrafa. Portanto,
solicite uma resposta não autorizada. Agora, a última
propriedade será uma propriedade
secreta ou chave. Essa propriedade manterá o token JWT em segredo para que os portadores do passaporte possam
decodificar o token JWT. Nós salvamos isso dentro do
arquivo como uma variável de entrada. Normalmente, processo que visa
importar o segredo do JWT. E então terminamos de
configurar nossas configurações de passaporte. Agora podemos seguir em frente e criar um método dentro da classe de estratégia
GW. Esse método será método síncrono
N
com a data do corpo do nome. Esse método aceitará uma carga útil e tudo o
que precisamos fazer é ver a carga útil
para o próximo roteador simplesmente retornando a
carga útil desse método. Agora podemos colocar o tipo
de carga útil. Já sabemos o formato
dessa carga porque
salvamos a carga dentro
do token JWT com
duas propriedades, o ID do usuário e o e-mail. E ambos
são do tipo string. Então, vamos adicionar dois pontos
e um objeto com propriedade id do usuário do tipo string
e e-mail do tipo string. Agora, na classe passaporte, criamos um objeto de usuário com
base no valor de retorno método validate e
o
anexamos como uma propriedade
no objeto de solicitação. Então, para seguir em frente, vamos abrir o
JWT Asgard, o arquivo ts. E aqui vamos
construir nosso DWT. Então, esses Guardas serão uma classe GWP de Deus. E essa classe
será uma classe injetável. Eles usarão
o decorador injetável. E vamos estender outra aula com
o nome de Deus. Você pode importar isso dos pacotes de passaporte
SES plus. Essa classe de
guarda aceitará
o tipo de estratégia de
autenticação. No nosso caso, estamos
usando a estratégia JWT. Então vá em frente e escreva DWT dentro da Terra e depois salve
esse arquivo, feche-o. Aqueles, a estratégia GW, o arquivo ts, retornam ao
nosso componente de bloco. E vamos implementar o início do método create. Portanto, vamos impedir que usuários
não autorizados criem
postagens
de blog dentro do nosso PR. Então, para fazer isso, vamos usar
o nivelador que você descarta, que será importado
do
ninho como pacotes menos comuns. E então aqui vamos
usar o JWT desprevenido que criamos
dentro do
DWT do oficial que eu vi naquele
cartão, o arquivo ts. Então vamos salvar isso e depois
vamos para o módulo do aplicativo. E aqui temos que importar nossa classe de estratégia JWT dentro da matriz de provedores
para que ela possa ser acessada em todo o
nosso aplicativo. Então vá em frente e adicione outro
item e escreva a estratégia JWT. Certifique-se de importar essa estratégia
de pontos do JWT dos slides
e, por que estamos aqui, vamos importar também o
controlador do usuário. A matriz de controladores
e o serviço ao usuário. E digamos que o provedor seja Eddie. Tudo bem, vamos voltar
ao controlador do blog. E ao implementar o
desprevenido, dessa forma, estamos protegendo
o Create Router de usuários não autorizados. Agora, podemos adicionar uma camada extra à nossa autenticação
adicionando uma propriedade de usuário dentro do
esquema de blocos para que possamos saber qual usuário
criou o documento do blog. Portanto, podemos dizer que o esquema do usuário vamos adicionar outra sonda
e torná-la necessária. E nomeie essa propriedade como usuário. Agora, essa propriedade será
do tipo classe de usuário. Certifique-se de importar isso
do arquivo de esquema do usuário. E também essa propriedade será uma referência
ao documento do usuário. Agora, para fazer isso, esse objeto, vamos adicionar
a propriedade type e defini-la como Mongoose. Certifique-se de importar o pacote Mongoose
do mongoose e, em seguida, selecionar o ID do objeto dos tipos de esquema. Porque queremos nos referir
ao usuário por seu ID e, em seguida, adicionar a propriedade href para definir a referência desse
produto ao modelo do usuário. Em seguida, salve o esquema do blog, feche-o e volte para
o controlador de fluxo. E dentro do método create, vamos extrair o
objeto do usuário da solicitação. Pode fazer isso dentro da lista de
argumentos
do método create. E usando o decorador reg, certifique-se de importá-lo
do pacote comum do SES. Agora, esse decorador
nos dará acesso à solicitação e vamos pegar o objeto do
usuário a partir daí. Então, dentro do método de criação do serviço de blog, vamos adicionar um, especialmente em um objeto
e o objeto aqui. E adicione uma propriedade do usuário
proveniente do usuário solicitado. Em seguida, adicione um ponto de
interrogação porque o objeto do usuário
pode ser indefinido. Em seguida, selecione o ID do usuário. Agora temos que ir para
os servidores do bloco. E dentro do
método create, aqui estão dentro da interface
do Creative Blog DTO. Temos que adicionar uma
propriedade de ID de usuário do tipo string. Salve o criado
PARA voltar aqui. E quando salvarmos, todas as flechas devem desaparecer. Aqui mesmo. Temos que mudar
isso para ID de usuário. Agora, dentro dos outros
roteadores, como na atualização, podemos realizar uma operação
para verificar se o usuário dentro
do documento de bloco solicitado tem o mesmo ID
de usuário o
ID de usuário extraído do token JWT. Podemos fazer a mesma coisa dentro do roteador delete one aqui. Vou deixar isso
como um desafio para você praticar seu ninho, sim. Escalas. Não deveria ser tão difícil. Você só precisa ler o documento do blog do
banco de dados, a propriedade do usuário, e verificar se ele é igual ao ID do usuário
extraído do token. Nesse caso, envie de volta
o documento do blog ou permita a ação de atualização
no documento de bloqueio solicitado. Então, com isso,
terminamos de criar nosso controlador de blog e implementar o aplicativo de autenticação
de dentro para fora. Você encontrará o resultado final anexado a esta seção de
recursos de vídeo.