Transcription
1. Annonce Apollo Graphql: Vous en avez assez des
API REST traditionnelles et souhaitez en savoir plus
sur les dernières nouveautés ?
Notre cours GraphQL
est la solution idéale pour le développement de la RPA . Dans ce cours, vous
apprendrez tout ce que vous devez
savoir pour démarrer
avec Graff Girls, commençant par les bases de la
création d' une Graciela
BI avec Express. Mais nous ne nous arrêtons pas là. Nous allons approfondir l'utilisation d'un serveur frontalier avec
TypeScript et Express, travail avec le type RM et l'utilisation base de données
Postgres avec docker. Notre cours n'est pas censé
être un graphique complet des coûts d'entretien, mais il vous apprendra
tous les éléments essentiels. Vous
découvrirez les filles Graff, les types de
halo, les requêtes, les
mutations, les schémas et comment fusionner des schémas et résolveurs. Une
photographe apprendra également TypeScript et Cover Socket IO et une
migration de base de données avec Diaper. À la fin du cours, vous serez en mesure de
créer en toute confiance votre propre API GraphQL et travailler avec certains des outils
les
plus récents et les plus puissants du secteur. Alors, qu'attendez-vous ?
Alors, ramez dès maintenant notre parcours de golf Gail et
passez à un niveau supérieur
en matière de développement d'API.
2. Introduction à Graphql: Bonjour et bienvenue à cette
première leçon sur Graph Gear. Dans cette leçon, nous allons
présenter le Dr Gale, discuter des requêtes et des mutations et expliquer ce qu'est un schéma. Qu'est-ce que GraphQL ? Graphql est un langage de requête et environnement d'exécution pour les API
développés par Facebook. Cela permet aux clients de demander exactement ce dont ils ont besoin
et rien de plus. Faites-en une alternative puissante
aux API REST traditionnelles. L'une des principales caractéristiques de Graph Gil est son langage de requête. Le langage de requête
permet
aux clients de spécifier
exactement les données dont ils ont besoin, y compris les structures de données imbriquées et de les récupérer
en une seule demande. Cela permet aux
clients de récupérer les
données du serveur de manière très efficace . Comme ils n'ont pas besoin de faire plusieurs demandes pour obtenir
toutes les données dont ils ont besoin. Parlons un peu
plus des requêtes. Au golf. Gayo, une requête
demande des données. Il spécifie le champ que
le client souhaite récupérer, ainsi que tous les arguments
requis. Voici un exemple de requête
simple dans GraphQL. Dans cette requête, nous demandons le nom et les champs e-mail de
l'utilisateur dont l'identifiant est 123 La réponse du serveur peut ressembler à ceci. Passons maintenant aux mutations. Les mutations dans GraphQL sont utilisées pour modifier les données
sur le serveur. Ils permettent aux clients d'envoyer
des données au serveur pour créer, mettre à jour ou supprimer des ressources. Voici un exemple de mutation
simple dans GraphQL. Dans le cadre de cette mutation, nous créons
un nouvel utilisateur nommé Jane Doe et nous envoyons un e-mail à Jane
Doe à l'adresse example.com. La réponse du serveur peut ressembler à ceci. Enfin, parlons des
schémas dans GraphQL. Le schéma est un contrat entre
le client et le serveur. Il définit les types de données qui peuvent être interrogés et mutés, ainsi que les relations
entre ces types. Le schéma est généralement défini à l'aide du langage de
définition de schéma GraphQL, ou SDL en abrégé. Voici un exemple de
schéma simple dans langage de
définition de schéma
GraphQL. Dans ce schéma, nous avons un type de requête avec
un champ utilisateur qui prend un argument et
renvoie un objet utilisateur. Nous n'avons pas non plus de type de mutation avec le champ create user qui prend un objet d'entrée Create User et renvoie un objet utilisateur. Binaire. Nous avons un type
d'utilisateur avec des champs d'identification, de
nom et d'e-mail. C'est tout pour cette
introduction au graphe Gail Nous avons expliqué ce qu'est Garcia, notre requête et les mutations
fonctionnent dans le schéma. Dans la leçon suivante, nous allons aborder la
création d'API GraphQL.
3. travailler avec des requêtes Graphql: Bonjour et bienvenue
dans notre cours GraphQL. Dans notre vidéo précédente, nous avons abordé les
bases de GraphQL, notamment les requêtes, les
mutations et les schémas. Dans cette vidéo, nous
allons créer un graphique simple que Gala
PI exprimera. Plus précisément, nous
utiliserons Express pour gérer nos
requêtes et réponses GraphQL. Et nous tirerons
parti de la puissance de Graff Girl pour récupérer
des données à partir d'une source de données. À la fin de cette vidéo, vous aurez une solide
compréhension de la création de l'
API GraphQL avec Express. Et vous serez en mesure d'appliquer ces concepts à
vos propres projets. Alors, sans plus tarder, plongeons-nous dans le vif du sujet et commençons à
créer notre graphique. Gala PI avec Express. J'ai préparé le
projet pour que vous le
suivre dans cette vidéo, vous pouvez le télécharger depuis
la section des ressources. J'ai inclus un
fichier index.js dans le projet. Ce fichier contient
le code nécessaire pour
commencer à écouter les
connexions avec Express. En plus de cela, vous trouverez un
fichier package.json avec trois dépendances. Express, Express, Dutch, Graff, Girl et Graph. Ici. Ce sont les principaux
outils que nous
utiliserons pour créer notre
API GraphQL que j'exprimerais. De plus, Node Money est également installé et configuré
dans le projet. Cet outil redémarre automatiquement notre serveur lorsque des modifications
sont apportées au code, ce qui nous permet de gagner
beaucoup de temps et faciliter le
processus de développement. Maintenant, avant de commencer à
travailler sur le projet, il est important de s'assurer que toutes les
dépendances nécessaires sont installées. Pour installer ces dépendances, accédez
simplement au répertoire
du projet dans votre terminal et exécutez
la commande npm install. Cela installera tous
les packages nécessaires à notre projet. Une fois l'installation
terminée, nous pouvons passer à la
création de notre graphique, obtenir un RPI avec Express. Maintenant, dans un projet Graph Gil, la première chose à
faire est de définir le schéma, qui est la
base d'un graphe. Obtenez le RPI en définissant ses
types et ses champs. Nous devons commencer par cela avant toute autre chose pour
garantir que nos API soient claires, auto-documentées,
flexibles et extensibles. Pour créer le schéma, nous devons importer
la fonction avec
le nom build schema
à partir du package GraphQL. Créez ensuite une
constante de schéma et utilisez la
fonction build schema en ouvrant deux parenthèses et
en transmettant une chaîne de modèle. Ici, nous allons définir notre première requête en ajoutant
le type de mot clé comme celui-ci, et en ajoutant la requête nommée. Ouvrez ensuite deux bretelles bouclées. Et ici, nous pouvons
définir nos requêtes. Je vais donc définir
une requête simple bonjour. Ensuite, nous devons définir le type de
retour de cette requête. Pour ce faire, ajoutez deux points, puis spécifiez le type de retour. Dans notre cas, la requête hello
va renvoyer une chaîne, assurez-vous d'ajouter un S majuscule. Leurs types sont utilisés pour définir
la structure des données,
y compris les types scalaires
tels que les chaînes, entiers et les booléens,
et les types d'objets, qui consistent en une
collection de champs. Maintenant, afin de gérer demandes provenant de
la requête Hello, nous devons définir
un résolveur racine. Le résolvable racine
est chargé récupérer les données
demandées dans la requête ou mutation et de
les renvoyer au client sous la
forme correcte définie par le schéma. Le
résolveur racine agit essentiellement comme un pont entre l'API
et ses sources de données, ce qui en fait un élément essentiel
de tout graphe girl ou PI. Maintenant, pour définir ce résolveur d'
itinéraires, créons une constante d'
itinéraire comme celle-ci et définissons sa
valeur sur un objet. Et cet objet, nous devons ajouter toutes nos requêtes avec le même
nom écrit dans le schéma. Je vais donc ajouter une propriété
hello représentant
la requête hello et définir sa
valeur sur une fonction de flèche. D'ailleurs, chaque requête ou
mutation doit être une fonction. Pour l'instant, renvoyons simplement
un message Hello World. Maintenant, nous devons définir un
Raphael et un buoyant dans notre API. Nous pouvons le faire en utilisant Express. Cela revient donc à
définir des intergiciels. Il a dit que c'était
le point final pour tuer Graff Girl. Et pour le gestionnaire de requêtes, nous utiliserons une autre fonction
nommée Dr. Gil HTTP. Nous pouvons l'importer depuis le package express, c'
est-à-dire GraphQL. Maintenant, à l'intérieur,
nous allons utiliser la
fonction HTTP GraphQL comme suit. Un objet comme argument. Le sujet
contiendra notre schéma. Vous pouvez le définir comme ceci ou simplement le nom schema
et JavaScript, nous saurons que nous faisons référence
au schéma constant. La deuxième propriété est la propriété de valeur
racine, qui contiendra
notre résolveur racine. Et la dernière propriété
est Graffiti Girl, un
client GraphQL graphique
interactif basé sur le Web qui permet aux utilisateurs d'interagir
avec un RPI GraphQL en exécutant des requêtes et des mutations et en visualisant les résultats. Lorsqu'elle est définie sur true dans la configuration express du
middleware GraphQL, l'option graphique active l'interface graphique pour tester et explorer
notre API GraphQL. Cela étant dit, enregistrons notre fichier, ouvrons le terminal et
exécutons ce document. Ouvrons ensuite le navigateur et naviguons vers localhost 4,000, tel que Scarf Girl, où vous trouverez l'interface
graphique. Ici, nous pouvons écrire nos
requêtes et même consulter la documentation
de notre gala de presse gouvernemental. Vous trouverez ici notre requête et à l'intérieur la requête hello, qui renvoie une chaîne. Si vous cliquez dessus, vous verrez la définition de
la chaîne scalaire. Maintenant, pour récupérer la
requête hello depuis ce serveur, nous devons définir
la requête de cette manière. Et puis j'ai mentionné
toute la requête à l'intérieur. Une fois que vous avez fait cela, cliquez sur le bouton Play pour
envoyer la requête au serveur. Si tout est correctement
configuré, vous devriez voir le
résultat des requêtes sur le côté
droit de votre client. Excellent travail. Dans la leçon suivante, nous allons continuer à explorer cette échelle en
découvrant les mutations.
4. Ajouter des mutations: Ajoutons maintenant une
mutation à notre API. La mutation GraphQL est donc un moyen de modifier les données sur le serveur à l'
aide de l'API GraphQL. Il permet aux clients d'envoyer la demande au
serveur pour créer, mettre à jour ou supprimer des données. Les mutations sont définies dans le schéma
GraphQL et peuvent être exécutées en envoyant un graffiti sur une requête de mutation au serveur. Définissons donc la
mutation en accédant
au schéma et en ajoutant un nouveau type. Et j'ai rencontré une mutation
avec un M majuscule Et supposons que nous
voulions que le client ajoute des produits à notre
serveur ici. C'est un identifiant de mutation ajouté
avec le nom add product. Ce gestionnaire acceptera un nom comme argument
de type chaîne, toujours avec S majuscule et
un prix de type int, qui fait référence à un entier. Ainsi, dans la croissance Gil, le type int représente un entier numérique
sinusoïdal de 32 octets. Il est utilisé pour définir
des champs qui renvoient ou acceptent des valeurs entières
dans le schéma du graphe G 0. Le type peut ensuite être utilisé pour appliquer validation
de type aux
requêtes et mutations GraphQL, en veillant à ce que seules des valeurs entières
valides soient fournies comme arguments. Nous pouvons définir ce
type selon les besoins en
ajoutant un point d'
exclamation devant celui-ci. Nous pouvons faire la même chose
pour l'argument du nom. Très bien, nous devons maintenant définir un type de retour pour cette mutation. La mutation GraphQL nécessite donc un type de retour pour
spécifier
la forme des données qui
seront renvoyées par le serveur après l'exécution de la
mutation. Donc, pour ce faire, ou insérez deux points
ici et ajoutez un tableau, car nous voulons renvoyer un
tableau d'objets de produit. Et pour définir le type
de cet objet de produit, allons-y, ajoutons-le un autre type et
nommons-le comme produit. Donc. Ce produit
contiendra un nom de type chaîne avec le
point d'exclamation pour le rendre obligatoire. Appuyez ensuite sur Entrée pour passer à la ligne suivante et
assurez-vous de ne pas ajouter virgule ici, car cela
n'est pas autorisé dans les schémas
Drift Gill. La deuxième propriété est le
prix du type integer. Nous pouvons également rendre le type de
retour obligatoire afin d'éviter d'
obtenir un résultat nul. Nous pouvons le faire en ajoutant un point d'
exclamation
devant le produit
et le tableau lui-même. Nous pouvons également modifier
la façon dont nous avons répertorié nos arguments de mutation
et les remplacer un seul argument, le nommer input et définir son type à
ajouter par entrée directe. Il s'agit d'un type personnalisé et non d'un type intégré de GraphQL. C'est pourquoi nous devons
le définir nous-mêmes. Nous l'appelons type d'entrée. Ainsi, dans GraphQL, le type d'entrée est type
spécial utilisé pour les arguments
dans les mutations et les requêtes Il est utilisé pour définir
la forme des données qui peuvent être acceptées
comme entrées par champ. Le type d'entrée peut contenir des types
scalaires tels que
string into ou boolean, ainsi que d'autres types d'entrée permettant des structures
imbriquées complexes. Les types de saisie sont similaires aux types
classiques et à la gestion des graphes, mais ils ne peuvent pas être
utilisés comme type de retour d'un champ pour définir le type d'entrée
Ajouter un produit. Allez-y, utilisez le mot clé d'entrée et
ajoutez le même nom. Et à l'intérieur, nous
ajouterons les mêmes arguments, nom du type string
et le même prix du type int. Maintenant, sauvegardons ce fichier et revenons à l'interface
graphique. Ici, nous pouvons ajouter notre requête de
mutation. Commencez par ajouter
une mutation en ouvrant Deux accolades bouclées sont
les accolades et la mutation d'
ajout de produit. Ensuite, ajoutez un
argument d'entrée à l'intérieur d'un objet, le nom du
produit qui indique SPC. Faites ensuite attention à la saisie du prix, car vous devez saisir
les nombres sous forme de chaîne, une chaîne qui fonctionne puisque nous avons défini
le type sur un entier, mais entrez plutôt les nombres
directement, comme ceci. L'objet renvoyé, nous
voulons obtenir le nom. Et le Bryce. Si vous appuyez sur le
bouton Play, cela ne fonctionnait pas. Et c'est parce que
nous n'avons pas défini le produit d'ajout pouvant être résolu
dans l'objet racine. C'est très rapide.
Ajoutez une virgule ici créez le produit publicitaire
et résolvez nos erreurs. Ce résolvable
acceptera donc un argument d'entrée. Mais pas directement comme ça, car l'
argument d'entrée existe à l'intérieur l'
argument de l'objet principal nommé args. Nous pouvons donc accéder à l'argument
d'entrée de cette manière. Ensuite, ce résolveur doit
renvoyer un tableau d'objets. C'est donc codé en dur et ajoutez un tableau avec un objet
avec deux propriétés. Nom, nous pouvons obtenir le nom
à partir de l'entrée comme suit. Et le prix à partir du prix point d'entrée. Ensuite, sauvegardons et testons à nouveau. Et voilà, nous l'avons. Notre tableau contenant un objet de
produit contient le nom et le prix. Nous pouvons indiquer au serveur de
ne renvoyer que les objets dont le nom est la propriété en supprimant
le champ de prix à partir d'ici. Appuyez sur Play. Et comme vous pouvez le voir,
nous avons un tableau d' objets contenant uniquement
la propriété name. Super. Maintenant que vous avez une compréhension
de base de GraphQL, passons à l'étape suivante pour améliorer votre
expérience en
apprenant à utiliser un graphe gail de portail avec Express et TypeScript. Apollo GraphQL est
un outil puissant qui fournit des fonctionnalités
telles que la mise en cache , la gestion des
erreurs et l'assemblage de
schémas. Il est ainsi plus facile de créer API GraphQL
évolutives.
En combinant une photographie Gil où ils expriment
et
TypeScript, vous aurez la
possibilité de créer vous aurez la
possibilité de créer des API GraphQL
hautement maintenables et sécurisées. Préparez-vous donc à remporter le
prix d'une photographe, Gill, et à faire passer vos
compétences de graphiste à un niveau supérieur.
5. Installation et configuration de Typescript: Avant d'entrer dans
la syntaxe TypeScript, nous devons d'abord installer le compilateur
TypeScript pour commencer à avoir une URL de téléchargement ovale ou TypeScript
lang.org slash. Et vous
trouverez ici plusieurs
façons d' intégrer le compilateur
TypeScript votre projet en fonction des outils
que vous
utilisez. Dans ce cours. Cependant, je vais m'
appuyer sur l'environnement NPM, car je
pense que c'est ce que la majorité des applications
JavaScript
utilisent de nos jours. Maintenant, peu importe où et
comment vous installez TypeScript, si vous n'avez pas encore de nœud, vous devrez l'installer en vous
rendant sur js.org
, puis en suivant les instructions
pour installer la dernière FTC. Maintenant, si npm est
installé sur votre système, revenons à la page de
téléchargement de TypeScript et copions
cette ligne ici. Ensuite, nous allons l'exécuter dans le cadre notre projet et
dans notre terminal. Assurez-vous donc de créer
un nouveau répertoire ici, ouvrir le code VS et d'exécuter
npm install TypeScript. Cela vous permet-il d'économiser
si vous souhaitez installer TypeScript dans votre projet et uniquement dans votre projet ? Mais cela signifie qu'
avec le bureau enregistré en tant qu'option div ici, vous ne pourrez
utiliser TypeScript que
dans ce projet. Vous pouvez le faire en, pour moi, je veux utiliser TypeScript
globalement à l'intérieur de chaque système. Je vais donc ajouter
le drapeau tiret g pour global, puis
exécuter npm install. Et vous devrez peut-être utiliser sudo pour exécuter cette
commande en tant qu'administrateur. Et si vous utilisez Windows, vous devez ouvrir une
nouvelle console d'administration. Maintenant, j'ai déjà TypeScript et je le stocke globalement
dans mon système. Je ne vais donc pas
exécuter cette commande. Et pour vous assurer que vous avez correctement
installé TypeScript dans votre système, vous pouvez exécuter TSE, c'est V, et vous obtiendrez
la version de TypeScript. Je suis actuellement sur la version 443. Et
peu importe que vous ayez une version de
TypeScript supérieure à la mienne. Parce que tous les centres
TypeScript que nous allons utiliser dans ce cours seront
applicables à toute
version supérieure de TypeScript. Maintenant, pour utiliser la syntaxe TypeScript
et le projet Self-Doubt, nous devons ajouter quelques configurations
TypeScript. Nous pouvons le faire automatiquement
à l'aide de la ligne de commande TSC, puis y mourir. Et comme vous pouvez le voir ici, nous avons un nouveau fichier dans notre projet, nommé
ts config dot json. Alors ouvrons-le. Et comme vous pouvez le constater, TypeScript propose ici de
nombreuses options. Beaucoup d'entre eux sont commentés parce que nous n'
allons pas les utiliser. Maintenant, la première
option non validée est la cible, qui représente la version du script
sigma. Dans ce cours, nous allons
utiliser mon script 6. Et si vous faites
défiler la page un peu vers le bas, vous trouverez la
propriété du module définie pour commenter. Oui. Cela signifie que les modules et la
compilation de fichiers dot js. Nous utiliserons la syntaxe du
niveau commun car presque tous les navigateurs prennent
en charge ce module. Mais si vous souhaitez que vos fichiers soient compilés avec une syntaxe
JavaScript moderne, vous pouvez essayer d'utiliser les années 2015, comme celle-ci, ES 2015. Mais comme je l'ai dit, nous allons
utiliser le fait de venir nous
voir dans ce projet. Maintenant, en dessous, nous avons la propriété
root qui spécifie l'emplacement des fichiers utilisant la syntaxe TypeScript. Finissons donc les commentaires et continuons à pointer vers
la racine de ce projet. Faisons maintenant défiler la page vers
le bas jusqu'à leur propriété, qui indique l'emplacement
des fichiers compilés. Alors, incrémentons-le. Et nous voulons que tous nos fichiers soient nos fichiers compilés qui se
trouvent dans le dossier dist. Nous n'avons pas besoin de créer
ce dossier manuellement dans notre projet car TypeScript le
fera pour nous. OK, maintenant c'est tout ce dont
nous avons besoin pour commencer. Sauvegardons donc le fichier de
configuration ts et commençons à utiliser la syntaxe TypeScript
dans la vidéo suivante.
6. Typescript de base: Il est temps de commencer à
apprendre la syntaxe TypeScript. Et pour cela, nous avons besoin d'un nouveau
fichier dans notre projet. Alors allez-y, créez
un nouveau fichier et
nommez-le main dot ts pour TypeScript. Ensuite, nous
allons commencer par
déclarer une variable
, la nommer FirstName, et la définir sur John. Maintenant, nous venons d'écrire du JavaScript
normal. Mais si je survole FirstName, je constaterai que FirstName
est de type chaîne. Maintenant, nous pouvons trouver la même
chose avec du JavaScript pur, mais essayons de définir
cette variable sur cinq. Maintenant, nous avons une erreur. Si vous passez la souris sur cette erreur, vous constaterez que TypeScript
se plaint du type ou de l'attribution d'une
valeur à cette variable. Il indique que le numéro de type
n'est pas assignable à une
chaîne de type car cinq ici est un nombre et John est une chaîne. C'
est donc comme si TypeScript disait que si vous assignez cette variable depuis le début à une chaîne, vous devez la conserver ainsi. C'est pourquoi TypeScript est
utile car il empêche petits bogues comme celui-ci d'
apparaître dans notre projet. Maintenant, nous voulons que la
variable firstname soit toujours
de type chaîne. Mais imaginons qu'un autre
développeur arrive et qu'il ait changé la valeur de la variable du
prénom en un nombre, disons dix. Maintenant, l'IRS a disparu de la deuxième ou
de la troisième ligne. Mais nous avons introduit
un autre dollar qui va ici. variable Firstname n'est
plus de type chaîne, mais de type numéro. Maintenant, vous vous
demandez peut-être pourquoi TypeScript ne nous a pas avertis que
nous avions commis une erreur ? Eh bien, c'est évident parce que nous
ne lui avons pas dit de le faire. Donc, pour
dire à TypeScript n'accepter que
des chaînes pour cette variable, nous devons ajouter deux points
puis une chaîne. Vous pouvez maintenant voir que
nous avons eu deux erreurs. Eh bien, c'est la même erreur, mais à deux endroits différents. Le
message est le même que précédemment. Le numéro n'est pas assignable à la chaîne
de caractères du même message. Nous pouvons le trouver ici. Pour résoudre ce problème, nous pouvons simplement supprimer les dix d'ici et les
remplacer par une chaîne. John. Nous pouvons en fait
supprimer cette variable car il s'agit de cette variable et attribuer cette variable à
la troisième ligne comme ceci. Et ici, nous pouvons voir que
l'IRS a disparu. Mais restons sur une seule ligne. Je vais donc le reprendre
et déplacer le prénom à partir d'ici
et l'attribuer à John. Maintenant, si vous souhaitez déclarer
un nombre au lieu d'une chaîne, nous pouvons créer une autre
variable, un nom et un âge, définir le type sur un numéro, puis nous connecter à n'importe quel
numéro, en choisissant 22. Et maintenant, vous savez
que si vous faites cela, vous obtiendrez une erreur indiquant que la chaîne de type n'est pas
assignable au numéro de type. Maintenant, nous n'avons plus que
des chaînes et des nombres, nous avons aussi des objets. Déclarons donc
une autre variable principale. Nommez-le LPG pour objet, puis définissez-le comme
un objet dont le
prénom de la propriété est défini sur chart. Maintenant, dans la ligne suivante, essayons de réattribuer la propriété FirstName à un numéro et voyons ce qui
va se passer. L'objet FirstName est donc égal à cinq. Maintenant, vous pouvez voir que
nous avons une erreur de TypeScript indiquant que le numéro de type n'
est pas assignable
à une chaîne de type. Et c'est normal,
car la déclaration propriétés
d'un objet est similaire à la déclaration de variables normales. Et même chose si nous essayons d'attribuer l'objet à
la variable firstname, nous obtiendrons la même erreur. Et cette fois, la chaîne de type horaire n'
est pas assignable à un type autre que l'objet que nous avons attribué à la variable
depuis le début. Supprimons maintenant
cela et attribuons le type de variable à un objet. Maintenant, vous pouvez voir que nous
n'avons reçu aucune erreur. Mais je tiens à
préciser que cette variable arbitraire
est un objet qui
contient une propriété FirstName de type chaîne. Nous pouvons le faire en retirant
l'objet d'ici le remplaçant par
deux accolades bouclées. Et à l'intérieur, voici la propriété du prénom
et définissez-la sur Type strain. Supposons maintenant que je souhaite ajouter une nouvelle propriété à
ce sujet, par exemple H. Nous obtiendrons une erreur indiquant ce type d'objet
avec la propriété FirstName, string et age number. Il n'est pas assignable à l'objet qui possède uniquement la propriété FirstName
de type chaîne. Maintenant, cela va être
très utile si nous voulons que nos objets ne contiennent que des
propriétés très spécifiques. Et bien sûr, si nous voulons ajouter la propriété d'âge,
qui est un nombre, nous pouvons venir ici, puis
ajouter l'âge du type numéro, et la flèche disparaîtra. Maintenant, après les chaînes,
les nombres et les objets, voyons comment définir des
fonctions avec TypeScript. Déclarons donc une nouvelle
fonction et nommons-la. Créez un utilisateur. Cette fonction
accepte deux arguments. premier est le prénom, second est l'âge. Vous pouvez maintenant voir ici
que nous avons deux erreurs. Firstname ou le paramètre FirstName
a implicitement un type quelconque. Désormais, les arguments des fonctions
sont également des variables. Et les scripts JavaScript définissent le type de ces arguments par
défaut sur le type any. Mais TypeScript
ne le permet pas, nous devons
donc ajouter des types
pour ces arguments. Donc, pour le FirstName, AddString, et pour
l'âge, il y a un nombre. Retournons maintenant quelque chose
à partir de cette fonction. Renvoie FirstName plus le h. Vous pouvez voir que nous n'avons
reçu aucune erreur car même TypeScript sait que nous voulons convertir l'âge chaîne, puis concaténer avec la variable
FirstName. Maintenant, si vous remplacez le
signe plus par un signe moins, vous obtiendrez une erreur. Comme TypeScript
sait qu'effectuer une opération de soustraction entre une chaîne et un nombre
n'est pas logique. Supprimons donc tout cela et remplaçons le par une chaîne
littérale. Et à l'intérieur, nous
aurons FirstName, puis ajouterons la variable firstname, puis age, la variable age. Créez une autre variable
et nommez-la chaîne stl. Ensuite, exécutons
la fonction de création d'utilisateur. Vous pouvez maintenant voir ici que
nous avons besoin de deux arguments. C'est donc le prénom de
John et l'âge de 22 ans. Maintenant, si vous passez la souris sur
la variable STR, vous la trouverez de type chaîne. Nous pouvons spécifier le
type de retour d'une fonction comme nous pouvons le faire pour une variable
en utilisant deux points ici,
puis ajouter une chaîne de type. Maintenant, supposons que je veuille
renvoyer un objet à partir de celui-ci. Merci pour ça. Je vais changer
cela avec un objet. Et nous obtiendrons une erreur indiquant que la chaîne de type n'est pas
assignable à l'objet type, mais que la variable STR
est de type objet. Maintenant, corrigeons cette
erreur en déplaçant cette chaîne et en la remplaçant par
un objet. L'autre est parti. Mais supposons que je
veuille renvoyer cet objet avec une propriété d'âge définie
sur l'argument aids. Si je souhaite utiliser
la valeur
de retour de la fonction utilisateur actuelle, qui est un objet censé contenir
une propriété d'âge. Nous obtiendrons une erreur indiquant que l'âge de la
propriété n'
existe pas dans l'objet type. Vous pouvez résoudre ce problème en supprimant cela, ajoutant un objet et la
propriété A avec le numéro de type. Maintenant, si vous passez la souris sur h, vous verrez qu'il existe
et qu'il a un numéro de type. Ajoutons également le
FirstName à l'intérieur cet objet et définissons-le comme étant égal
à l'argument firstname. Ici, nous avons une erreur
car nous devons ajouter la propriété FirstName
au type
de retour de cette fonction. Donc FirstName de type string. Ça va ? Supposons maintenant que si nous
avons un sida supérieur à 20, nous allons rejeter ce sida
et ne renvoyer que le prénom. Donc, ici, ajoutons une
instruction if et vérifions si l'âge est égal ou supérieur à. 20. Si tel est le cas, nous allons renvoyer uniquement un objet doté de
la propriété FirstName. Maintenant, TypeScript
ne veut pas me laisser renvoyer cet objet
sans la propriété age. C'est parce que nous lui avons dit que cette fonction allait
renvoyer un objet avec uniquement la propriété age de type number et la
propriété FirstName de type string. Nous pouvons résoudre ce problème en rendant la propriété d'âge non obligatoire en ajoutant un point d'
interrogation ici. Maintenant, l'erreur a disparu. Et si vous passez la souris sur aides, propriété constatera que h est
de type numéro ou indéfini. Maintenant, vous pouvez faire
la même chose pour l'
insatisfaction liée à l'âge, mais uniquement si cet argument est le dernier des
arguments suivants. Maintenant, si nous ajoutons le point d'
interrogation ici, nous obtiendrons une erreur indiquant que l'objet est
peut-être indéfini. Maintenant, vous vous demandez peut-être pourquoi nous
sommes bouleversés ici, et non pas pourquoi. Eh bien, c'est parce qu'
en JavaScript, tout est un
objet, même des fonctions. Mais vous pouvez trouver le type de l'argument d'âge sous forme
numérique ou indéfini. Si nous modifions l'emplacement de cet argument et le
plaçons depuis le début ici, vous obtiendrez une autre erreur. Dire qu'un paramètre obligatoire ne peut pas suivre un paramètre
facultatif. Donc, si vous ajoutez un point d'
interrogation ici, la flèche a disparu
de la liste des arguments, mais vous obtiendrez de nombreuses erreurs dans la fonction et en dehors la fonction où
nous l'avons exécutée. Maintenant, nous n'en voulons plus. Nous voulons
tout changer tel qu'il était. Permettez-moi donc de le supprimer d'ici, le
mettre là et de supprimer le point
d'interrogation de l'argument H. Maintenant, supposons que nous voulions que
cette fonction accepte
les aides sous forme de nombre
ou de chaîne. Nous pouvons le faire en ajoutant une barre verticale et
en ajoutant le type de chaîne. Bien entendu, nous devons
faire la même chose pour le type
de retour de cette fonction. Permettez-moi de fermer ceci pour
avoir plus d'espace et d'
ajouter une barre ici avec
ce type de chaîne. Maintenant, l'âge ici est de type, chaîne, de nombre ou indéfini. Nous pouvons faire la même chose
pour une variable, par exemple pour le prénom ici Ajoutons une
chaîne ou un nombre. Ou faisons-le pour notre âge. Nous avons donc ici un chiffre. Ajoutons une chaîne. Ça va ? Nous pouvons maintenant
attribuer la variable
d'âge à un nombre
ou à une chaîne. Comme ça.
7. Tapage avancé: Maintenant, pour en revenir à la fonction utilisateur
actuelle, imaginez si nous avons plus de propriétés
dans cet objet avec des types plus complexes. Dans ce cas, il ne
sera pas pratique d' avoir un gros objet
devant cette fonction. Et pour résoudre ce problème, TypeScript a introduit ce
que l'on appelle des interfaces. Une interface est également un objet, mais vous ne pouvez l'utiliser
que comme référence à un type. C'est ainsi que nous pouvons déclarer
une interface en utilisant le mot clé interface puis
le nom de l'interface. Et je vais choisir l'utilisateur. Et comme je l'ai dit, nous allons créer un objet, mais sans
signe égal ni colonne. Vous pouvez le considérer comme une classe. Maintenant, prenons tout cela, l'âge et le prénom. Coupez-le à partir de là,
supprimez l'objet, supprimez les deux points et collez-les ici dans
cette interface. Ajustons un peu le
code. Vous pouvez entendre utiliser une virgule, mais vous pouvez également utiliser un point-virgule ou vous pouvez simplement
supprimer n'importe quoi de là. Mais je veux utiliser des points-virgules car cela semble plus
organisé de cette façon. Maintenant, nous pouvons utiliser l'
interface utilisateur comme n'importe quel autre type. Ici, les deux points, puis
l'interface utilisateur. Et si vous passez la souris sur aides, vous constaterez que
l'âge a toujours les caractères chaîne,
chiffre et indéfini. N'oubliez pas que les interfaces ne font référence qu'
à un type d'objet. Donc, si vous retirez les bretelles
frisées d' ici et que vous laissez simplement
les aides, vous trouverez. Vous obtiendrez une erreur indiquant
que la chaîne ou le nombre
n'est pas un type utilisateur assignable
car l'utilisateur possède, tout d'
abord, deux propriétés
et l'utilisateur est un objet. Et effectuez les modifications. Et créons une autre
fonction et nommons-la login. Cette fonction n'acceptera qu'un seul argument et portera
le nom login ox. Il va être de type login. Et bien sûr, nous allons
définir une interface de connexion. Permettez-moi donc de copier ce nom. Voici l'interface et
définissez l'interface de connexion. Ainsi,
pour qu'un utilisateur puisse se connecter, vous aurez également besoin d'un
e-mail de type chaîne et du mot de passe de
type chaîne. En fait, je veux
contrôler le type de mot de passe lors de l'utilisation de l'interface de connexion dans la fonction de connexion. Pour ce faire, nous pouvons modifier
la face centrale pour qu'elle soit générique en ajoutant deux crochets
angulaires comme celui-ci. Et puis vous pouvez maintenant considérer
cette interface comme une fonction qui acceptera
un argument en tant que type. Et nous pouvons choisir le
nom de l'argument. Je vais choisir
PWD comme mot de passe, et je vais attribuer
ce type au mot de passe. Maintenant, ici, si vous
passez la souris sur login, vous constaterez que la connexion de type
générique nécessite un argument de type. Comme je l'ai dit, les fonctions
ont des arguments. Donc, pour le type générique,
c'est le même concept. Nous pouvons maintenant définir
cet argument en ajoutant crochets inclinés
et le type de mot de passe
qu'il contient sous forme de chaîne. Maintenant, avec satisfaction,
vérifions très rapidement si l'
e-mail à points de connexion est égal, par exemple, qu'il a créé et le mot de passe à point de connexion est égal, par exemple, au mot de passe. Dans ce cas, nous
allons revenir à la réalité. L'utilisateur est donc authentifié. Maintenant, sinon, nous
allons renvoyer False. Je vais définir le type de la valeur de retour de
cette fonction sur body. Et c'est un nouveau
type que nous pouvons utiliser. Et cela n'a pas besoin de définition car le booléen
est juste vrai. Faux. Maintenant, pour revenir à
l'interface de connexion, nous pouvons utiliser une autre variable
qui ne fait référence qu'à un type et qui contient le type
de mot de passe pour nous. Et comme le mot de passe n'
est pas un objet, nous ne pouvons pas utiliser le mot clé
interface. Nous pouvons uniquement utiliser l'alias
de type, puis nommer le type en tant que type
de mot de passe. Ensuite, nous pouvons ajouter ces
chaînes à ce type. Alors, voici une chaîne. Ensuite, nous pouvons utiliser
le type de mot de passe dans l'interface de connexion. Si vous passez la souris
dessus, vous verrez que le type de mot de passe est une chaîne. Vous pouvez ajouter ici
une chaîne ou un nombre. Et vous pouvez ajouter le
type de votre choix. Mais les mots de passe ne peuvent
être que des chaînes ou des chiffres. Nous pouvons également utiliser l'
alias de type pour ajouter un type à une variable ou à la valeur de
retour d'une fonction. Donc, ici, je vais
ajouter le type login, résultat est égal au volume et m'
assurer qu'il est en majuscules. Et ici pour le corps, et nous pouvons utiliser une minuscule
ou une majuscule. C'est la même chose. Modifions-le
pour obtenir des résultats de connexion. Maintenant, imaginez que nous
ayons une fonction asynchrone. Nous allons utiliser le
mot clé async pour définir cela. Dans ce cas, nous avons reçu une erreur indiquant que
le type de retour d' une fonction
ou d'une méthode asynchrone doit être le générique de promesse globale
avec le type d'argument T. Puis il dit : « Vouliez-vous écrire
ce type générique ? Maintenant, si vous connaissez JavaScript, vous saurez qu'
une fonction asynchrone renverra une promesse. Et c'est ainsi que nous pouvons définir un type de promesse avec TypeScript. Changeons donc le résultat de la
connexion pour qu'il soit une promesse, car cette fonction va renvoyer une promesse. Ensuite, le générique
ou l'argument de ce type générique représente le type de retour réel
de cette fonction, ou en d'autres termes, la valeur résultante ou le type de
résolution de cette valeur. Nous allons donc
résoudre un booléen. Et vous pouvez voir que
l'erreur a disparu. Maintenant, supposons que si nous
authentifiions l'utilisateur, nous enverrons un objet
au lieu de true. Et cet objet contiendra
une propriété de nom d'utilisateur, dite à nouveau à John, et une autre propriété dont
le statut sera défini comme actif. Nous avons donc un utilisateur actif
dans notre base de données. Bien sûr, nous n'
avons pas de base de données ici, mais imaginez simplement
que nous en avons une. Maintenant, bien sûr, nous
allons avoir une erreur. Et pour résoudre ce problème, ajoutons une
interface ici et nommons-la,
numérotons-la et citons-la. Nous aurons la
propriété username de type string et la propriété status également
définie sur string. Et ici, nous aurons
une promesse qui
résoudra soit un
booléen, soit un nombre. J'ai donc commis une erreur ici. l'heure actuelle, la Terre
a disparu et nous pouvons renvoyer
une force ou un objet. En ce qui concerne la propriété status, nous ne pouvons renvoyer que trois statuts, le statut actif, le statut
inactif et le nouveau statut. Ici, vous devez donc toujours
renvoyer l'une de ces chaînes. Mais si j'écrivais Active comme ça, dans ce cas, j'ai fait une faute de frappe. Mais TypeScript
n'a rien dit. Comme TypeScript ne
connaît pas ces chaînes, il ne s'
intéresse qu' au type de la propriété
d'état indiquée à String. Et comme vous pouvez le voir ici, j'ai déjà fait une faute de frappe. Alors, comment pouvons-nous prévenir ce
type d'erreurs ou d'erreurs ? Eh bien, c'est très simple. Nous devons déclarer un type d'énumération. Donc, ici, utilisez les
idées NM, puis nommez ce statut de membre de type enum. Et ce sera un objet, mais cela ne fera pas
référence à un objet. Je vais vous expliquer comment nous pouvons
l'utiliser en une seconde. Nous pouvons maintenant définir
ces trois types en ajoutant actif et inactif. Et puis le nouveau statut. Nous devons maintenant remplacer
cette chaîne ici par l'énumération du statut des membres. Et pour cela, nous devons également utiliser les nombres (status enum )
à 2 pour sélectionner
le statut actif. C'est si actif. Vous pouvez voir ici que les trois types de VSCode un succès, car cela est très utile pour accélérer le processus de
développement. Maintenant, choisissons Actif. Et si vous passez la souris dessus, vous constaterez que le
statut des membres actifs est égal à zéro. Vous pouvez maintenant faire référence à l'état actif sous la
forme d'une chaîne en ajoutant égal. Puis actif. Même chose pour les inactifs. Ici, chaîne, copie inactive. Et pour les nouveaux, je savais aussi. Maintenant, si vous passez la souris sur Actif, vous verrez qu'il est actif au
même titre qu'une chaîne. Désormais, dans l'interface membre, nous ne pouvons accepter qu'une seule
de ces propriétés. Alors maintenant, nous n'aurons plus
peur de mal orthographier
l'un d'entre eux. Maintenant, sauvegardons ce fichier ouvrons le terminal
et essayons de compiler. Nous pouvons le faire facilement en utilisant la commande TSC et en appuyant
simplement sur Entrée. La commande TSC
va vérifier si nous
avons des erreurs ou des erreurs
de type script. Et puis si tout va bien, nous aurons un dossier dist
contenant le fichier main.js. Si vous l'ouvrez, vous
trouverez ici beaucoup de code. Mais tous les types d'avant, du fichier main.js,
ont disparu et nous n'
avons que du JavaScript pur. Vous pouvez voir comment TypeScript
compile le type enum. Et j'ai fait tout cela pour nous. Skulls, le
point principal, le point js est un fichier. Et maintenant, vous pouvez dire que vous avez appris à peu près
tout sur TypeScript. Avant de terminer la vidéo, permettez-moi de vous
montrer très rapidement
comment utiliser la méthode de connexion. Alors voilà, prenez le
non-jeu et transmettez l'objet avec l'e-mail défini
comme e-mail , mot de passe, mot de passe. Et puis comme il s'
agit d'une fonction asynchrone, nous allons utiliser la
méthode pour obtenir le résultat. Ensuite, nous allons vérifier si le statut est actif ou non. Et pour ce faire, nous
allons créer une instruction if et vérifier d'
abord si le résultat est une instance de
la classe Boolean. Et d'ailleurs, le booléen avec le B majuscule est du verre. Et c'est un tourbillon pour le type Boolean avec
le b minuscule. Ce type ne fait
donc ici référence
qu'à un vrai ou à un faux. Mais le booléen avec B
majuscule fait référence à une classe qui contient
le type Boolean. Je vais donc le faire. S'il s'agit d'une instance de
Boolean, retournez. Sinon, prenez le
résultat comme tel. Chèque. Si tel est le cas, ce statut est égal
à celui de connexion ou de membre. État actif. Si c'est le cas, nous allons revenir
à la réalité. Ou peut-être le journal de la console. L'utilisateur est actif. L'utilisateur est actif. Maintenant, si vous souhaitez utiliser
le corps et les minuscules, modifiez-le et
vous pouvez vérifier le type de booléen avec type de mot-clé, puis résultat est égal pour
garantir son volume. Et si vous souhaitez
effectuer une
telle vérification avec le point d'exclamation, vous pouvez supprimer le type
booléen d' ici et le remplacer par null. Et au lieu de renvoyer false, allez renvoyer null. C'est mieux comme ça. Et vous pouvez
voir que null est également un type. Vous trouverez maintenant
ce fichier joint à cette vidéo avec d'autres ressources
TypeScript. Assurez-vous donc de les télécharger et d'en savoir plus sur
TypeScript par vous-même.
8. Créer le schéma graphql: Je suis dans VSCode et
j'en ai deux cinq, le fichier de configuration ts et la
banque a le fichier JSON. Maintenant, pour le fichier de configuration ts, nous avons de nouvelles options, comme si la bibliothèque était
réglée sur yes, 2021. Et la
résolution du module est également définie sur note, les types
étant également définis sur note. Maintenant, pour l'option d'
initialisation stricte des propriétés, assurez-vous qu'elle est définie sur false ou vous pouvez simplement la supprimer
de votre fichier de configuration ts. Maintenant, fermez-la et d'ailleurs, je vais ajouter un fichier zip à je vais ajouter un fichier zip à
cette vidéo afin que vous puissiez la trouver dans les ressources et les téléchargements. Nous allons maintenant ajouter
quelques packages de MPM. Voici donc le
terminal du VS Code. Vous pouvez l'ouvrir en cliquant ici sous terminal et en
cliquant sur nouveau terminal. Je vais donc
installer de nouveaux packages comme l'express avec les
types pour express. Et nous allons travailler avec le serveur
Apollo avec Express. Je vais donc installer
un polo Server Express. Et bien sûr, nous avons besoin de GraphQL
et des types de GraphQL. Donc, ici, à Types
Slash Graph Gear. Et juste au cas où je devrais
installer les types de notes. Exécutons maintenant cette commande et installons tous
ces packages. Très bien, maintenant, laissez-moi effacer ce terminal et, dans
le répertoire racine, créons un nouveau dossier
source. Et à l'intérieur, nous
aurons un
fichier main.js et un fichier dot txt du module. Et pour l'instant, nous
n'allons pas toucher à ces deux fichiers car nous devons d'abord créer le
schéma GraphQL. Et pour cela,
assurez-vous d'être à nouveau dans le répertoire racine et créez un nouveau fichier et nommez-le schéma. Ce Raphael. Très bien, maintenant voici le schéma
GraphQL composé
de mutations et de requêtes. Nous utilisons des mutations lorsque nous voulons modifier des données dans la base de données. Et nous utilisons des requêtes lorsque nous voulons obtenir des données de la base de données. Vous pouvez
les considérer comme des publications dans requêtes si nous
utilisions une API RESTful. Cela étant dit,
définissons notre première mutation. Et pour ce faire, nous devons utiliser le mot clé type
, puis écrire mutation. Et à l'intérieur, nous
aurons la mutation d'inscription. Alors c'est vrai, inscrivez-vous et inscrivez-vous. Il va accepter
la saisie de l'utilisateur. Nous allons donc
écrire ici une entrée comme argument pour cette méthode. Et nous devons définir le
type de cette entrée afin que lorsque nous utiliserons cette
mutation avec notre API, nous sachions quels arguments sont obligatoires et lesquels ne le sont pas. Et définissez ce type. Nous devons utiliser le
mot clé de saisie ici, n'est-ce pas ? Entrez, puis nommez ce type
d'entrée Inscrivez-vous ici, et assurez-vous d'avoir un S
majuscule ici pour nous, pour son type ou sa précision et ce n'est pas obligatoire, mais c'est une chose
courante avec GraphQL. Donc, ici,
côté saisie de l'inscription, nous allons
définir les arguments d'inscription. Et d'ailleurs,
vous n'avez peut-être pas la syntaxe de GraphQL
colorée comme ceci. Parce que si vous le souhaitez, vous devez installer une
extension pour GraphQL. Rendez-vous donc dans la
section des extensions ici et recherchez l'extension
GraphQL. Je l'ai déjà
installé ici. Veillez donc à installer
la même extension. Et puis vous devrez peut-être créer un fichier de configuration après avoir
installé ce paquet. Faites donc défiler la page vers le bas et vous
devez créer un fichier YAML point GraphQL fc point,
copier ces deux lignes et les coller
dans votre projet. Et vous pouvez voir ici
que ce fichier de configuration, nous commençons à cibler les
anciens fichiers GraphQL contenus dans notre dossier source. Dans notre cas, nous
n'en avons pas encore besoin, mais à l'avenir, nous aurons
plusieurs fichiers GraphQL. se peut donc que vous deviez
également copier cette ligne et la coller dans
le fichier de configuration. Et je le ferai également
de mon côté. Juste pour être sûr
que nous n'
oublierons pas cela à l'avenir. Revenez donc à notre projet
et dans le répertoire racine, créez un nouveau fichier et nommez-le point GraphQL LRC plutôt que GMO. Et ici, collez ce
code ici et fermez-le. Et puis vous aurez les
mêmes styles pour GraphQL. Et pas seulement les styles, mais aussi la saisie semi-automatique. Oui. C'est pourquoi je vous recommande d'installer cette
extension et de l'utiliser. Chaque fois que vous créez un graphe,
éliminez un schéma juste pour éviter les fautes de frappe et le débogage inutile si vous avez commis des erreurs ici. Oui. Donc, juste pour m'assurer que j'ai le GraphQL dans le répertoire
racine, poursuivons avec
la saisie d'inscription. Donc, pour créer un nouvel utilisateur, nous avons besoin d'un e-mail de type chaîne. Et assurez-vous
d'avoir un S majuscule ici. Et assurez-vous également que
vous n'avez pas ou que vous ne venez pas ici. Et maintenant, définissez également le
mot de passe de type chaîne. Et nous avons également besoin d'un prénom
de type chaîne et du nom
de famille de type chaîne. Et maintenant, utilisons ce type
ici pour la saisie d'inscription. Et comme vous pouvez le voir ici,
c'est similaire au
TypeScript lorsqu'il s'agit de définir et d'
utiliser des types. Oui. Vous n'aurez donc peut-être
aucune difficulté à comprendre la syntaxe de
GraphQL, n'est-ce pas ? Définissons maintenant le type de retour de
la mutation d'inscription. Désormais, chaque fois que nous nous déconnecterons, nous récupérerons l'utilisateur, le document utilisateur
et le jeton JWT. Définissons donc cela. Et cette fois, nous devons
utiliser le mot clé type, car le mot clé d'entrée
n'est utilisé que lorsque nous voulons définir les entrées pour
des mutations ou des requêtes. Et le type est utilisé pour définir principalement les types de retour des
mutations et les requêtes. Définissez maintenant un type et
nommez-le réponse terrestre. Et ici, nous aurons un utilisateur. Et puis celui-ci
sera de type utilisateur. Et nous allons définir
cela dans une seconde. Et ici, nous avons également besoin du jeton
JWT de type string. Maintenant, en plus de tout
cela, vous allez définir l'utilisateur saisi. Nous devons également définir l'identifiant
de l'utilisateur, car lorsque nous commencerons à
utiliser la base de données, nous allons renvoyer l'identifiant. Oui, nous devons donc définir
cela, sinon nous n' obtiendrons pas l'identifiant
du schéma GraphQL lorsque nous
demanderons le document utilisateur. Donc, voici la carte d'identité. Et comme nous
utilisons le type rep, nous utiliserons des
couches. Avec Postgres. L'identifiant
sera de type numéro. Mais dans GraphQL, nous ne pouvons pas utiliser, nous n'avons pas
de type numérique comme celui-ci, mais nous avons un type N. Oui. Et juste pour nous assurer
que nous obtiendrons l'identifiant
à chaque fois que
nous demanderons l'accès à l'utilisateur, nous ajouterons un point d'
exclamation ici. Et avec ce symbole, nous pouvons définir un
champ obligatoire dans notre schéma. Maintenant, l'utilisateur dispose également de
tous ces éléments ici. Permettez-moi donc de copier ceci
et de les coller ici. Et c'est tout. Utilisons maintenant le type d'utilisateur
ici ou le type de
réponse de l'auteur. Alors voilà, déséquilibré,
puis économisez. Nous devons maintenant nous assurer
que l'entrée d'inscription est
également requise pour éviter d'
obtenir des entrées indéfinies. Il en va de même pour
la réponse de la Terre. Oui, et maintenant nous
devons définir notre schéma. Et pour ce faire, je vais utiliser
le mot clé schema. Alors cite ceci. Nous allons
définir la mutation. Et ce sera
du type mutation. Ensuite, lorsque nous créons la
requête, les requêtes, nous pouvons venir ici et créer une requête comme celle-ci, puis
lui donner le type de requête. Mais pour l'instant, nous n'avons qu'une
mutation et assurez-vous qu' au moins vous avez
soit une mutation soit une requête ici, soit les deux. Sinon, vous êtes la
passerelle GraphQL qui ne résoudra pas. Maintenant, enregistrons ceci et créons un résolveur qui
gérera cette logique d'inscription.
9. Créer un résolveur Auth: Maintenant que notre schéma
GraphQL est défini, créons un résolveur. Et comme nous avons défini une mutation d'inscription
liée à l'authentification, nous allons créer un dossier
dans le dossier source. Et à l'intérieur, nous allons
avoir un fichier de résolution. Et ici, nous allons définir l'objet qui
contiendra notre logique de mutations
et de requêtes. Créez donc une nouvelle constante
et nommez-la en tant que résolveurs. Et ce sera un objet
doté d'une propriété de mutation. Et à l'intérieur de cela, nous allons
définir la méthode d'inscription. Et bien sûr, leur
méthode d'inscription est une méthode asynchrone. Maintenant, les
résolveurs GraphQL auront un argument parent et
un objet contenant la valeur d'entrée
ainsi qu'un argument ou un argument de contextes
constants. Nous allons expliquer l'argument contextuel lorsque nous définirons le principal et le module. Mais pour l'instant, nous savons
que nous allons
recevoir une contribution de notre résolveur d'
inscription. Et tous les arguments
contenus dans l' entrée d'
inscription seront définis ici. Pour l'argument parent, nous allons avoir
la valeur
de retour du résolveur parent. Et ce n'est que lorsque nous
avons des résolveurs imbriqués. Mais dans notre projet, nous
n'allons pas l'utiliser. Mais je peux, je peux vous
montrer un exemple. Imaginez donc si nous voulions
trouver une mutation d'inscription, mais pas de cette façon. Nous allons créer un autre
type et le nommer, inscrivez-vous. Et ici, nous aurons
comme un e-mail. Et cette méthode
renverra l'ensemble des utilisateurs. Et nous devrons également, comme avec Google, nous
inscrire auprès de Google. Et celui-ci renverra
un jeton de type chaîne. Donc, pour l'utiliser, nous pouvons également ajouter l'entrée
à la méthode de largeur ici, puis supprimer
ces maladies parentales. Et ici, la mutation d'inscription est que vous allez
être du type inscription. Et avec cela, nous avons défini un résolveur imbriqué dans
les résolveurs de l'auteur ici, nous devons définir la mutation d'
inscription comme ceci. Et nous ne reviendrons que
comme un objet vide. Et puis en dehors de l'objet de
mutation, nous allons avoir
un type d'inscription. Créez donc une
propriété d'inscription ici. Et à l'intérieur, nous allons définir la largeur de l'e-mail
à l'aide
des méthodes de Google. Oui, donc ici avec courrier électronique et ensuite
ce sera une méthode. Bien sûr, c'est asynchrone. Mais maintenant, nous pouvons avoir le parent. Oui. Et dans notre
cas, dans cet exemple, le parent
sera un objet vide, mais c'est ainsi que nous pouvons obtenir le résultat imbriqué de la façon
de créer résolveurs
imbriqués et d'utiliser
l'argument parent. Mais comme je l'ai dit, nous
n'allions pas l'utiliser
parce que c' est trop tuer. À mon avis. Nous voulons juste un résolveur simple. Retournons tout comme avant et supprimons
le type d'inscription. Très bien. Maintenant, dans les résolveurs Earth, vous pouvez voir ici que nous avons erreurs de script
indiquant que tous
ces arguments n'
ont pas de type ces arguments n'
ont pas et que cela
n'est pas autorisé avec
TypeScript, comme vous le savez. Dans la vidéo suivante,
nous allons
apprendre à générer automatiquement des types TypeScript à partir
du fichier GraphQL à points de schéma.
10. générer des fichiers typescript à partir du schéma: Maintenant, afin de générer
automatiquement des types frappés à partir de notre schéma GraphQL, nous devons installer
de nouveaux packages. Alors rendez-vous sur votre terminal
et exécutez npm install dash, D
majuscule pour la dépendance au développement. Et puis à droite, le nom du compartiment, GraphQL, c'est
Cogent Slash CLI. Et nous avons également besoin d'autres
plug-ins pour ce package. Encore une fois, co-général. Et nous avons
besoin du plug-in TypeScript. Et encore une fois, des résolveurs
TypeScript
GraphQL slash ou a
dash co-gen slash. Et lancez cette commande. Et maintenant, dans notre fichier
package.json, nous allons créer
une autre commande ici et la nommer generate. Et nous allons utiliser
le coaching GraphQL. Ensuite, nous allons spécifier un fichier de configuration et
le nommer cogen point YAML. Bien sûr, nous n'
avons pas encore ce fichier. Créons donc dans le répertoire racine et
enregistrons ce fichier de configuration. Nous allons spécifier
le chemin du schéma. Dans notre cas, il se trouve dans
le répertoire racine, puis dans Schema point GraphQL, puis sous generate. Nous allons enregistrer
les types générés
dans le dossier source. Et puis dossier généré latéralement. Et puis dites que les résolveurs
utilisent un fichier dot txt. Et maintenant, nous devons
spécifier les plugins. Nous avons donc installé
le plugin TypeScript, et nous avons également installé les résolveurs TypeScript. Et maintenant, nous devons ajouter quelques configurations
liées à TypeScript. J'utiliserais donc la
signature d'index sur true. Et cette option nous permet de générer des
types TypeScript dynamiques. Ajoutez maintenant deux points ici
et enregistrez ce fichier revenez au
fichier package.json et enregistrez-le également. Exécutons ensuite cette commande
depuis le terminal npm, exécutons-la, générons-la et attendons-la. Très bien, nous avons
réussi à générer nos divs dans les types de
résolveurs. Vous pouvez voir que
nous avons la réponse de notre utilisateur et de
notre auteur ici dans nos types d'entrées d'inscription aux mutations. Oui, l'utilisateur est là et
tout est déclaré. Bien sûr, il existe de nombreuses configurations et autres
types liés à Graph Girl. Oui, fermons ce fichier
maintenant, revenons aux résolveurs d'
auteur et
importons les résolveurs à partir des résolveurs générés. Fermons ce dossier
et revenons ici. Les trois solveurs
utilisent donc ces
types énumérés que nous devons
importer depuis la source ou depuis
le dossier généré. Et à partir du fichier de types de résolveurs, nous allons importer des résolveurs. Et nous devons implémenter
ce type ici. Et maintenant, nous pouvons voir que toutes les
erreurs TypeScript ont disparu. Parce que
TypeScript sait maintenant que la propriété de mutation
possède une méthode d'inscription. Dans la méthode d'inscription se trouve un résolveur GraphQL
et son brouillon, votre résolveur a un parent
, une entrée et un contexte. Et maintenant, si vous écrivez une entrée, vous obtiendrez
des suggestions à partir
du type de saisie d'inscription. Continuons maintenant à créer
la méthode d'inscription. Et je ne vais
renvoyer que des données factices ici. Nous devons donc rendre une pièce d'identité. Ou en fait, vous devez
renvoyer une propriété utilisateur. Et à l'intérieur, nous aurons le nom d'utilisateur et son numéro
de type. Ajoutons l'ID1 et l'e-mail. Ensuite, ajoutons simplement
un e-mail aléatoire ici et renvoyons le
prénom et le nom de famille. C'est juste pour les tests,
car nous devrions commencer à travailler sur le fichier principal et le fichier du module et
tester nos résultats. Maintenant,
ajoutons le nom de famille. Ce sera
juste pour l'utilisateur et sûr. Donc, en fait, nous devons
utiliser l'entrée ici. Nous devons renvoyer l'entrée provenant de l'
utilisateur, du client. Je vais donc répartir toutes les propriétés dans
l'argument d'entrée. Et vous pouvez voir
que nous n'avons aucune erreur de la part de TypeScript. Cela signifie donc que nous renvoyons les mêmes propriétés que celles qui
existent pour citer l'utilisateur. Vous pouvez donc voir ce côté, le schéma GraphQL, nous avons le mot de passe e-mail, prénom, le nom de famille, le type d'utilisateur et le même dans les entrées d'inscription. C'est pourquoi nous n'
avons aucune erreur. Maintenant, nous devons encore
retourner le jeton JWT. Et celle-ci ne
sera qu'une chaîne aléatoire. Maintenant, si vous l'avez remarqué, nous n'avons reçu aucune erreur lorsque le jeton JWT nous manquait. Oui. Et c'est parce que le
schéma Saturday point GraphQL, nous n'avons pas ajouté de point d'
exclamation ici. Nous devons donc ajouter
ceci ou rendre ces deux propriétés
obligatoires et enregistrer ce fichier. Et maintenant, nous devons réexécuter
la commande generate afin de nous assurer que
l'auteur résout. Nous renvoyons le
jeton JWT avec la propriété utilisateur. Nous avons donc
généré le schéma, et voilà, nous avons une erreur TypeScript indiquant
qu'il nous manque le DWT. Donc, ici, si nous ajoutons
la propriété DWT, la Terre disparaîtra. Et pour l'instant, nous allons
simplement envoyer des données factices. Ensuite, une fois que nous aurons terminé le fichier
principal et le fichier du module, nous reviendrons ici et terminerons toutes les
mutations et requêtes. Et c'est parce que nous
devons toujours nous connecter à une base de données et créer l'entité utilisateur
dans cette base de données. Cela étant dit,
dans la vidéo suivante, nous allons commencer à travailler sur le module et
les fichiers principaux.
11. Configurer notre serveur Apollo-express: Maintenant, dans le
module, le fichier ts, nous allons configurer notre serveur Apollo pour qu'il fonctionne
avec notre schéma GraphQL. Et l'auteur est un solveur. Commençons donc par
importer quelques packages. premier est le serveur Apollo d'Apollo Server Express et Import Express
depuis Package Express. Et nous avons également besoin du paquet
http à partir du paquet HTTP. Et vous n'avez pas besoin de
l'installer car nous avons par défaut avec NodeJS. Très bien, maintenant, exportons et créons une nouvelle classe
et nommons-la module d'application. Dans cette classe,
nous allons avoir un constructeur qui
acceptera les résolveurs. Donc, créez ici une
variable publique et nommez-la résolveurs, et elle sera
de type résolveurs. Nous devons l'importer depuis
le dossier généré et depuis
le fichier des types de résolveurs. Et ici, nous avons une
erreur car nous devons
importer et utiliser des
résolveurs, pas des résolveurs. Ajoutez-y donc un S. Et ici, nous allons créer une méthode qui lancera
le serveur Apollo. Alors, le glaçage démarre Apollo. Et cette méthode devrait revenir. Bien sûr, c'est une promesse, et la promesse doit résoudre un objet avec un serveur HTTP, propriété de type serveur HTTP. Et nous devons renvoyer un serveur ou une propriété de type serveur
Apollo. Créons maintenant une constante
et nommons-la serveur, et utilisons la classe de serveur Apollo pour créer une nouvelle instance de
serveur Apollo avec certaines configurations. Nous devons donc transmettre ici notre schéma
GraphQL et nos résolveurs. Et je vais
commencer par les résolveurs et transmettre
cette variable ici. Et bien sûr, nous
sommes dans une classe, nous devons
donc utiliser ce
mot clé, puis les résultats. Passons maintenant au schéma, nous avons la propriété type
deaths. Et nous devons prendre ce fichier, le schéma point GraphQL, et le transmettre ici. Et pour cela, nous allons utiliser la méthode de synchronisation des fichiers en lecture
à partir de nos paquets alphas. Voici donc Read File Sync
et importé depuis fs. Et avant cela, sur le serveur, nous allons créer une constante
de décès de type. Et ici, nous allons utiliser le Read File Sync
pour lire le schéma GraphQL à
partir du schéma de
ce fichier GraphQL. Permettez-moi donc de supprimer ceci. Et voilà, nous allons continuer. Nous devons spécifier le chemin. Et comme nous avons ce fichier GraphQL schématique
dans le répertoire racine, nous pouvons l'écrire comme ceci. Schema Graph Girl. Et nous allons lire ce fichier avec un encodage réglé sur UTF huit. Parce que sans l'option d'
encodage, nous allons
récupérer un tampon. Mais ici, nous avons besoin d'une ficelle. Enlevez donc le côlon et donnez
simplement à ce type de
décès. Maintenant, nous devons démarrer le serveur, alors attendez que le serveur démarre. Ensuite, nous devons créer
ou utiliser le middleware d'application. Et ici, nous allons
ajouter une médulla express. Créons donc d'abord une application avec Express et
utilisons-la ici comme une application médiévale. Ok, maintenant, nous devons
renvoyer un serveur HTTP. Mais l'application ici
n'est pas de type HTTP. Ce serveur
est de type express. Nous allons donc utiliser les paquets HTTP pour
créer un serveur HTTP à l'aide de l'application, je parle de l'application Express. Donc, ici, créez une nouvelle constante
et nommez-la serveur HTTP, puis utilisez http point, créez un serveur et
transmettez-la là-haut. Ensuite, voici
le serveur HTTP renvoyé avec
le serveur Apollo. Maintenant, nous devons
lancer une nouvelle instance et l'exporter à partir
du fichier du module. Donc, ici, exportez du son
constant puis créez une nouvelle instance de module d'
application. Ici, nous devons
transmettre les résultats. Nous devons donc d'abord importer
l'auteur est terminé. Importez donc ici nos résolveurs, et je pense que nous ne les avons pas exportés depuis le fichier ogres de
l'auteur. Alors faisons-le ici. Exporter, exporter. L'auteur est solveurs. Ensuite, laissez-moi copier ceci, revenir à un module et
importer les résolveurs de l'auteur go out ou
depuis l'intérieur du dossier Earth et dans les résultats de
l'auteur. Maintenant, revenons ici et
utilisons les résolveurs ici, puis enregistrons ce fichier. Et dans la vidéo suivante, nous allons commencer à travailler
dans le fichier main.js.
12. Exécuter et tester nos api: Dans le fichier main.js, nous devons importer
le module depuis le fichier de module, puis
créer une fonction d'amorçage. Et ça va être asynchrone. Et à l'intérieur, nous allons
extraire le serveur HTTP et le serveur du module
qui lance une méthode de mise en bouteille. Ensuite, nous utiliserons
le serveur HTTP pour
initier ou commencer à écouter, car les connexions se comptent
toutes deux par milliers. Ensuite, nous renverrons un message
à la console indiquant que serveur est prêt sur
http localhost. Et puis le port 4 000. Et ici, nous devons obtenir le chemin de la passerelle GraphQL
à partir du serveur Apollo. Je vais donc ajouter ici une autre chaîne
provenant du serveur, cette propriété de chemin GraphQL. Ensuite, nous obtiendrons le
chemin de la passerelle GraphQL. Très bien, maintenant, nous devons encore
exécuter la fonction bootstrap s'appelle la fonction
bootstrap. Maintenant, enregistrons le fichier
main.js, dirigeons-nous fichier
package.json et ajoutons
quelques scripts pour exécuter notre application. Donc, ici, créez une nouvelle commande de
démarrage et nous devons compiler
notre code, puis exécuter le fichier main.js. Et cette fois, nous
allons utiliser le
tiret, quelle option sans T, au lieu d'utiliser des paquets
Node Man. Et pour utiliser cette option, vous devez disposer de la
dernière version de Notes. Oui. J'ai donc la version
19 qui devrait en avoir au moins 18. Assurez-vous donc de mettre à jour
votre version de Node.JS. Ensuite, voici le chemin
d'accès au fichier main.js. Donc, ce dossier, puis le dossier source
, puis le fichier principal dot js. Maintenant, prenons la commande TSO ici et
mettons-la dans une autre commande. Alors ici, créez une commande de
compilation et collez-y le TSC. Alors ici, nous allons
exécuter npm, exécuter compiler. Nous allons donc compiler notre code,
puis exécuter le fichier main.js et surveiller les mises à jour
ou les modifications. Sauvegardons maintenant le fichier
package.json et les clubs. Et ici, dans le terminal, exécutons npm, exécutons start. Et nous avons une erreur. Et c'est parce que nous devons
ajouter une requête à notre schéma. Donc, pour l'instant, nous
n'utilisons pas de requêtes, mais je vais ajouter une requête
très simple. Donc, ici, sous mutation, pour exécuter ou créer un
nouveau type de requête à l'intérieur, je vais créer une requête
qui renverra une chaîne. Et ici, le schéma
définit une requête. Et puis ici aussi,
recherchez et enregistrez. Et cette fois, nous
devons régénérer les types et créer
un résolveur pour cela. Donc npm run, generate. Et puis dans les résolveurs de
l'auteur. Créons une requête
ici et obtenons la méthode. Il faut donc que ce soit une propriété,
puis la citer. Nous aurons la
méthode get et nous
ne retournerons qu'une chaîne. Je vais donc renvoyer
une chaîne LK, puis enregistrer et exécuter à nouveau l'
application. Ici, npm, cours, commence. Très bien, nous
avons maintenant notre serveur sur localhost 34,000 slash GraphQL. Et ici, il semble que
nous ayons ajouté une barre oblique, mais nous corrigerons cela plus tard. Passons maintenant à notre navigateur, naviguons
vers localhost 4,000 GraphQL et cliquez sur Query your server pour que
nous puissions y accéder. Studio photo. À partir de là, nous allons
tester nos mutations et nos requêtes. Très bien, nous sommes maintenant dans sandbox
Apollo et, sous root, vous trouverez la
requête et la mutation. Maintenant, nous allons commencer par dépoussiérer la mutation et
essayer de nous inscrire. Bien sûr, nous avons des données fictives, mais nous ne testerons ici que la passerelle
GraphQL. Donc, pour ajouter la requête d'inscription, cliquez sur l'icône plus et vous obtiendrez la mutation, puis l'inscription avec la saisie. C'est ainsi que nous définissons
notre mutation à partir
de la lumière, du front-end
ou du client. Donc, ici, l'entrée est une variable et elle est de
type Entrée d'inscription. Nous obtenons donc ce type
grâce au schéma, bien sûr. Et nous
définissons ici la mutation d'inscription
ou la méthode d'inscription. Oui, donc c'est juste le
type de mutation, et c'est la véritable mutation. Et nous ajoutons ou définissons l'argument d'entrée pour qu'il soit
égal à cette variable. Et nous pouvons, ah, modifier la
variable d'entrée à partir d'ici. Comme vous pouvez le voir ici, nous
sommes dans la
section des variables et nous pouvons définir toutes les variables
requises. Maintenant, dans la méthode d'inscription, nous allons également définir le type de retour et le schéma GraphQL du
samedi. Vous pouvez voir que la
mutation d'inscription renverra une réponse et que l'autre conjoint a un champ utilisateur
où se trouve le champ JWT. Nous pouvons donc spécifier ici la
propriété que nous allons obtenir. Donc, dans notre cas, nous allons obtenir l'utilisateur et nous
n'avons que l'intérêt
et l'identifiant. Et puis nous aurons x, ou nous attendons
le DWT. Et c'est tout. C'est ce qu'il y a de
cool à propos de GraphQL. Vous permet de décider quelles données vous
souhaitez obtenir en réponse. Ainsi, plutôt que de renvoyer l'intégralité du document utilisateur l'intégralité du document utilisateur
avec le mot de passe de l'e-mail, le
prénom et le nom de famille, nous pouvons demander
à draft girl de ne renvoyer que l'identifiant et le jeton JWT , bien
sûr, car nous utiliserons pour
authentifier l'utilisateur. Exécutons maintenant cette requête en
cliquant sur le bouton S'
inscrire ici. Et bien sûr, nous avons oublié
d'ajouter l'entrée. Cette demande échouera donc. Indique que l'entrée de la variable n'
est pas nulle et ne doit pas être nulle. Alors voilà, changeons cela. Et à la place des arguments
ici, section arguments, nous pouvons trouver l'entrée de
type Sign-up input et vous pouvez ajouter les
types nécessaires ici. Permettez-moi donc d'effacer tout cela dans
l'e-mail, mot de passe et le
prénom, le nom de famille. Ils sont tous obligatoires. Maintenant, pour l'e-mail,
vous allez choisir uniquement celui de
l'utilisateur sur email.com, et pour le mot de
passe, vous n'enverrez que le mot de passe, prénom, l'utilisateur, et le nom de famille de l'année
dernière, l'utilisateur. Maintenant,
renvoyons cette requête ou cette mutation et
attendons la réponse. Très bien, nous avons l'identifiant de l' un et le jeton JWT
sous la forme de cette chaîne ici. Et vous pouvez vérifier que cette
chaîne est la même que celle que nous avons définie dans l'instruction
return ici. Donc, le JWT ou la propriété. Notre passerelle GraphQL
fonctionne donc avec les serveurs Express
et Apollo. Et testons
également très rapidement la requête. Oui, nous allons donc
exécuter la méthode get, assurer de la laisser
là et d'ajouter la requête get. Ajoutez donc ceci ici
dans le getMethod. Et pour cette requête, nous ne nous attendons pas
à recevoir de données. Par conséquent, nous pouvons simplement écrire la méthode get comme
ceci sans parenthèses, n sans aucun argument, puis exécuter la requête et
nous devrions obtenir, d'accord, une chaîne. Très bien, nous l'avons ici. Nous savons maintenant que toutes
nos requêtes et mutations fonctionnent et que nous
pouvons exécuter nos résolveurs. Maintenant, nous devons
terminer de travailler sur la mutation d'inscription et terminer tous les résolveurs ici. Mais avant cela, nous devons utiliser type around pour créer une entité
utilisateur afin pouvoir créer un utilisateur et l'
enregistrer dans la base de données.
13. installer et configurer typeorm: Dans ce projet,
nous allons utiliser
type round pour gérer
notre base de données. Il existe de nombreux
organismes, mais le plus populaire
est le type rampe. Et c'est parce qu'il
possède de nombreuses fonctionnalités et qu'il est facile à utiliser,
en particulier avec TypeScript. Désormais, un OR est un mappeur
relationnel d'objets. Vous pouvez cliquer sur ce
lien ici et vous
serez redirigé vers
une page Wikipédia. Vous pouvez en savoir plus sur la
cartographie relationnelle des objets ici. Oui. Mais TypeScript, ou notre rampe de type,
signifie TypeScript, object relational,
mapper et type around. Il s'agit d'une bibliothèque qui
permet de relier facilement nos applications TypeScript
à une base de données relationnelle. Et dans notre cas, nous allons utiliser Postgres
comme base de données relationnelle. Et bien sûr, Diaper Amps prend en charge de nombreuses
autres bases de données, compris MongoDB, mais c'est encore
au stade expérimental. Donc, si vous voulez utiliser
MongoDB, vous pouvez le faire, mais vous devez ajouter de
nombreuses autres configurations. Parce que comme vous le savez, lorsque nous utilisons Mongoose, nous avons rencontré quelques difficultés
lorsque nous voulions implémenter TypeScript
avec les modaux Mongoose. Oui, donc la même chose
se produit ici avec Diaper M, mais nous avons beaucoup d'autres
options comme Postgres, C-Corps, My SQL ou Sequel Light et toutes les autres bases de données. Vous pouvez maintenant accéder à la saisie titre du
paramètre et en savoir
plus sur ses fonctionnalités. Mais bien sûr, dans ce projet, je vais vous apprendre
comment installer le type Rahm, comment l'utiliser, comment
créer une entité, quel type d'entité, et bien
d'autres choses encore. Ouvrons donc notre VS Code. Et à l'intérieur du terminal, commençons par installer type around et le pilote Postgres. Et nous avons également besoin d'un autre
package nommé Reflect Meta Data, car nous
allons taper ou M
utilise les caractères. Et pour utiliser les caractères
avec TypeScript, nous devons installer le
Reflect me the data ici. Donc, c'est moi, ces données. Sinon,
nous ne pourrons pas
exécuter notre application. Assurez-vous donc de l'installer. Et si vous n'avez pas
installé les types de note, assurez-vous de le faire. Oui, je l'ai installé
depuis la première vidéo. Je vais donc exécuter cette commande et
attendre l'installation. Très bien, maintenant dans
le fichier main.js, nous devons importer les
métadonnées reflétant Beckett
afin d'utiliser les caractères. Alors laissez-moi copier ceci. Et si
vous choisissez main.js, c'est parce que c'est notre
fichier principal pour ce projet. Je vais donc
tout importer depuis l'importation. Cela me fait penser que
Theta met entre crochets ici. Et nous devons ajouter quelques
configurations ici. Et donc la configuration ts
qui dit quelque chose de drôle. Nous devons donc ajouter
deux propriétés supplémentaires. premier est l'émission, les caractères, les métadonnées
et le réglage sur true. Et les
décorateurs expérimentaux se sont également concrétisés. Et ces propriétés sont
très importantes lorsque nous
voulons exécuter ou utiliser les caractères
de notre application. Maintenant, si vous ne savez pas
quels sont les personnages, quels sont les personnages, nous en apprendrons davantage à leur sujet lorsque nous
commencerons à créer nos entités.
14. Créer une entité utilisateur: Maintenant que nous avons intégré
la rampe de saisie dans notre projet, commençons par créer
l'entité utilisateur. Donc, dans le dossier, créez un autre dossier et
nommez-le côté utilisateur ici, créez un autre
dossier nommé entity. Ensuite, dans
le dossier de l'entité, créez l'utilisateur, cette
entité, le fichier ts. Maintenant, nous allons
importer l'
entité de caractère à partir de type wrap. Ensuite, nous allons exporter
un nom de classe, un teaser. Et ici, nous allons
utiliser l'entité décoratrice. Et c'est ainsi que nous définissons
les entités avec la couche m. Maintenant, les caractères
ne sont que de simples fonctions. Oui, That's renvoie
une autre fonction, mais utilise également
des arguments très spécifiques et ils ont besoin du package de données Reflect Me
pour fonctionner. Oui, donc si vous
voulez créer un décorateur, vous pouvez effectuer une recherche en ligne, mais je vais vous donner un exemple
très simple. Imaginez donc que nous ayons une entité ici. Imaginez que nous voulions créer une entité, le personnage. Je vais donc le faire, je vais créer une constante
et la nommer entité. Ensuite, je vais
créer une fonction. Et cette fonction doit
renvoyer une autre fonction. Maintenant, la deuxième fonction
doit accepter une cible et
une clé de propriété. Car Tiki peut être du type chaîne et aussi
quelque chose appelé distributeur. Ce grip est là. Et celui-ci est de type descripteur de
propriété. Bien entendu, nous ne devons pas utiliser le
distributeur de fonctions pour une classe. C'est pourquoi nous avons
une erreur ici. Oui, mais vous pouvez
en savoir plus sur les distributeurs dans
la documentation. Par TypeScript ici, vous pouvez
en savoir plus sur les personnages. Copiez donc ce lien et vous pourrez savoir beaucoup
sur les distributeurs de classes, par exemple ici, comment nous les construisons ici. Nous créons donc ici une fonction
avec un constructeur. Le constructeur
n'est qu'une fonction. Ensuite, nous utilisons ici de nombreuses méthodes
JavaScript pour gérer ou extraire
les propriétés et les méthodes de la classe et en faire
quelque chose. Oui, maintenant, assurez-vous, si vous voulez en savoir
plus à leur sujet, venir ici et, par exemple d'essayer de fabriquer vos propres outils
ou vos propres décorateurs. Oui, mais pour l'instant, supprimons cela et continuons
avec notre entité utilisateur. Maintenant, nous avons besoin d'un prénom au
sein de notre entité utilisateur. Alors ici, écrivez le prénom. Et celui-ci va
être de type chaîne. Et assurez-vous qu'il s'agit d'une chaîne
TypeScript. Je veux dire, avec une minuscule comme. Et nous devons utiliser
un autre personnage ici. Et ce caractère
s'appelle une colonne. Donc, tapez la colonne
around et utilisez-la ici. Colonne. Nous avons maintenant le FirstName, le LastName, le
nom de famille de type string. Et bien sûr, je vais
réutiliser la colonne. Et nous avons également besoin
de l'e-mail de type string. Et puis la colonne.
Et ce qui est cool
avec le type où m est, c'est même si vous avez utilisé une base de données MongoDB
ou toute autre base de données, vous pouvez définir, vous devez toujours définir les entités de la
même manière avec la même structure. À l'exception de Mongoose. Parce que, comme je l'ai déjà dit, c'est encore au stade
expérimental. Oui. Et il était là
depuis longtemps, mais vous pouvez toujours travailler avec,
mais vous devez créer un schéma. Nous ne pouvons pas créer d'entité
avec Mongoose avec couche. Passons maintenant
à l'entité utilisateur. Nous avons toujours besoin du mot de passe, et il s'agit toujours d'une chaîne
de caractères ici. Et je vais ajouter une
configuration pour le mot de passe. Et pour ce faire, nous pouvons
passer un objet ici et dire ou une propriété, sélectionner et la définir sur false. Et cela signifie que nous ne
voulons pas que le mot
de passe soit renvoyé au client. Oui, nous voulons masquer le mot de passe et voici
comment nous le faisons avec la saisie. Nous pouvons maintenant ajouter de nombreuses
configurations, par exemple pour l'e-mail ici, nous le pouvons. J'ai dit que nous ne
voulions pas que l'image ne le soit pas. Nous utilisons donc la
propriété nullable et la définissons sur false. L'e-mail ne sera donc pas, Non. C'est comme une validation
avec diaper n, mais nous allons utiliser une autre méthode de validation,
plus avancée. Oui. Maintenant, nous avons toujours
besoin de la carte d'identité ici. Mais comme l'idée est automatiquement générée
par les versions postérieures, nous allons utiliser un autre
décorateur pour définir l'identifiant et sorte que le caractère soit appelé colonne générée
principale. Et ici, nous allons
utiliser ce décorateur. La colonne primaire est donc générée. Et ici, nous allons définir l'identifiant. Et comme je l'ai dit pour PostgreSQL, nous allons obtenir
des idées et des chiffres. Maintenant, enregistrons cette vidéo
et la suivante Nous allons créer
le service utilisateur et commencer à utiliser l'
entité utilisateur. Alors on se voit là-bas.
15. Créer une méthode utilisateur | user.service: Maintenant, dans le dossier utilisateur, créons un autre fichier et
nommez-le niveaux de service utilisateur. Et ici, exportons et
créons le service utilisateur de la classe. Et puis je vais
ajouter un constructeur. Et à l'intérieur, nous
allons définir une variable publique et la
nommer référentiel utilisateur. Et ce sera
du type référentiel. Et nous allons importer
l'interface du référentiel à partir de machines à écrire, et ainsi de suite, le référentiel
à partir de type ramp. Et ici, au dépôt. Et nous devons transmettre
l'entité ici. Si vous passez la souris dessus, vous constaterez qu'il est nécessaire pour l'utiliser
dans notre classe. Nous allons donc ajouter ici
l'entité utilisateur et nous
devons l'importer à partir de
l'entité utilisateur du fichier. Donc, pour chaque utilisateur de l'entité utilisateur ou
à l'intérieur du fichier d'entité, utilisez ou cette entité. Maintenant, nous pouvons commencer par
créer la première méthode, qui est la méthode create, dans laquelle nous allons créer un nouvel utilisateur. Donc, créez de manière asynchrone. Et puis, pour les arguments, ce
sera une entrée d'inscription. Et nous allons également utiliser les types
générés automatiquement ici. Le type pour la
même entrée ici. Attribuons donc l'argument
d'entrée d'
inscription à l' entrée, à l'interface et au type d'inscription. Et nous allons l'importer à
partir d' un niveau,
puis de deux niveaux. Et Site Generated
va sélectionner le type de résolveur et
l'entrée d'inscription. Et si vous passez la souris sur
l'entrée d'inscription, vous trouverez toutes les propriétés
requises ici,
comme l'e-mail, le prénom, le nom de famille et le mot de passe. Bien sûr, sans
l'identifiant parce qu'il l'est, il est généré
automatiquement. Et ici, corrigez l'async. Maintenant, la première chose à
faire dans la méthode create est de
hacher le mot de passe. Pour cela, nous avons besoin d'
un autre package. Ouvrons donc le terminal. Et je vais bloquer le
Beckett nommé Decrypt. Et nous l'utiliserions pour
transmettre notre mot de passe et également pour comparer les mots de passe lorsque nous voulons
connecter l'utilisateur. Alors voilà, npm installe la crypte. Et nous devons également installer
les types pour, soyez correct. Exécutez ensuite cette commande. Attendez l'installation,
et c'est tout. Permettez-moi d'effacer cela et de
fermer le terminal. Et maintenant, laissez-moi abandonner la classe
Big Rip depuis la crypte. Et ici, nous allons
créer de nouveaux mots de passe,
un mot de passe haché. Attendez le chiffrement. Ce haschich. Et à côté, nous allons
transmettre les informations d'inscription. Alors inscrivez-vous ici. Entrez ce mot de passe. Ensuite, nous devons
choisir une rondelle de sel. Alors voilà, je vais en choisir
dix pour les ronds de Salt. Et ici, nous recevons une
erreur car le mot de passe, si vous le
survolez, vous constaterez que toutes les
propriétés du type de
saisie d'inscription ne sont pas requises. Pour changer cela. Nous devons accéder
au schéma de GraphQL. Et à côté, ajoutez un point d'exclamation sur
toutes les propriétés ici. Et faisons de même
pour l'utilisateur. Nous n'en avons donc besoin que
pour le mot de passe. Oui. Parce que nous n'
allions pas le renvoyer. Et puis c'est réglé.
Sauvegardons ça. Et nous devons ouvrir le terminal
et générer les types. Alors ici, npm run, generate. Et c'est tout. Laissez-moi effacer cela ou fermez
simplement le terminal. Retournez au service utilisateur et l'erreur a disparu. Et maintenant, le mot de passe est de
type chaîne avant qu'il ne soit de type peut-être ou
quelque chose comme ça. Ils utiliseront ici une autre interface ou une classe pour définir les propriétés
non requises. Mais quand c'est nécessaire, nous utilisons ce type ici, mais c'est automatique, dégénéré. Ça ne nous intéresse pas. Continuons maintenant à
créer l'utilisateur. Maintenant, créez une constante utilisateur, puis utilisez ce référentiel
utilisateur à points,
puis créez une méthode à partir
du référentiel utilisateur. Et ici, nous allons diffuser l'utilisateur ou l'
entrée d'inscription, la saisie d'inscription. Ensuite, nous allons
ajouter le mot de passe ici. Je sais donc que dans
l' entrée d'inscription, nous
avons déjà un mot de passe, mais lorsque nous répartissons les anciennes propriétés comme celle-ci
dans un objet, puis ajoutons une autre propriété portant le même nom qui existe
dans l'entrée d'inscription. Nous allons en fait
mettre à jour cette propriété. Et nous allons définir
le mot de passe à cette valeur pour le mot de passe
HashSet ici. Maintenant, laissez-moi, nous
devons sauver l'utilisateur. Et pour ce faire, nous devons utiliser cette méthode de sauvegarde par
points du référentiel utilisateur et transmettre le document utilisateur nouvellement
créé. Bien entendu, nous allons renvoyer ce document au client. Il l'a donc renvoyé
et attendez-le. Et puis enregistrez. Maintenant, pour utiliser le service utilisateur à l'intérieur
des résolveurs de la Terre. Et comme l'auteur est un
solveur et qu'il s'agit d'un objet, nous ne pouvons pas ajouter de variable publique et lui attribuer le type de service
utilisateur. Nous devons donc créer
une instance à partir
du service utilisateur et exporter afin de pouvoir
l'utiliser dans les résultats de l'auteur. Oui, donc, d'accord, exportez, puis utilisez un service utilisateur constant et allez ajouter une nouvelle
instance de service utilisateur. Et ici, nous devons transmettre
le référentiel des utilisateurs. Et pour cela, nous devons
créer la source de données. Et à partir de la source de données, nous allons obtenir
le référentiel des utilisateurs. Nous le ferons dans
la prochaine vidéo.
16. ajouter une source de données d'application: Créons maintenant
la source de données de l'application ,
puis revenons ici. Donc, dans le dossier source, créez un nouveau fichier et nommez-le, y compris la source de données, le Ts. Et ici, nous devons importer la
classe de source de données depuis Diaper. Et ici, nous devons
exporter une constante, lui attribuer un
nom de source de données. Et ce sera égal à une nouvelle instance de classe de source de
données. Et ici, nous allons avoir
le type de base de données. Et dans notre cas, nous allons utiliser la base de données
Postgres. Vous pouvez voir ici que nous
avons beaucoup de bases de données, comme je l'ai déjà dit, je suis malade ou que nous avons beaucoup d' autres bases de données
comme MongoDB ici. Donc, pour nous, nous allons
utiliser Postgres. Et vous devez choisir
Postgres dans ce projet ,
car ensuite
, nous utiliserons Docker
pour exécuter base de données
Postgres dans
notre système local. Oui. Donc, si vous souhaitez
suivre ce cours, vous devez également
choisir Postgres. Maintenant, nous avons besoin de l'hôte de
la base de données et, dans notre cas, nous allons exécuter la
base de données sur l'hôte local. Et nous allons
choisir le port. Et pour Postgres, nous
avons le port 5432, et nous avons besoin d'un nom d'utilisateur
pour la base de données. Toutes ces informations
seraient également ajoutées utilisées lorsque nous
initions notre base de
données Postgres avec Docker. Voici donc le nom d'utilisateur
qui va choisir Admin. Et pour le mot de passe, je vais également choisir admin. Et puis le nom de la base de données, ce sera la base de données principale. À présent, nous devons
définir nos entités. Les entités. Il s'agit d'un tableau qui contient tous
les fichiers d'entités. Vous pouvez donc spécifier le
chemin de son entité. Mais il existe une meilleure façon de
procéder : d'abord, nous avons désélectionné
le dossier dist, puis nous avons ajouté deux étoiles pour choisir ou
rechercher dans n'importe quel dossier. Et puis ajoutez une étoile ici, puis l'entité point que possède G. Maintenant, en utilisant ce chemin, nous allons sélectionner tous les fichiers du dossier
dist et tout dossier existant
dans ce dossier dont le nom se
termine par
une entité point. Oui. Maintenant, j'ai encore besoin de plus de
propriétés comme la journalisation. Nous ne voulons pas recevoir de requêtes de suite
dans notre terminal. Donc, pour la journalisation, je
vais choisir false. Et nous devons ajouter l'option de
synchronisation ici. Mais assurez-vous de ne le
définir comme vrai que lorsque nous développons notre
base de données ou notre projet. Et vous pouvez lire ici la
documentation de cette propriété. Et c'est un
avertissement indiquant que si vous utilisez l'option et
le mode de production, vous perdrez comme vous
utiliseriez des données de production. Donc, en gros, cette option ici, nous allons mettre à jour la base de données. Et comme nous
utilisons Postgres, il s'agit d'une base de données relationnelle. Il mettra
ensuite à jour les tables
de base de données
entre toutes les entités. Mais ce n'est pas un
moyen sûr de mettre à jour le schéma. Par conséquent, nous ne l'utiliserons que. Utilisez cette option ici. Ensuite, nous travaillerons avec, nous ajouterons des patients, et nous
supprimerons cette option ici. Donc, pour l'instant, restons sur
true et revenons
au service utilisateur. Et nous devons importer
la source de données, la source données à partir d'
un niveau sortant, deux niveaux par rapport à la mise à jour. Il est donc là et nous l'
utiliserons ici. Source de données, puis dépôt Git à
points. Et nous devons ajouter la cible. Et la cible est
un type d'entité. Nous devons donc transmettre
l'entité utilisateur ici afin de pouvoir obtenir
le référentiel des utilisateurs. Maintenant, dans la vidéo suivante, nous allons commencer à travailler
avec l'auteur de ses solveurs. Et nous allons terminer
cette inscription ou ne pas la terminer, mais commencer à travailler sur cette méthode d'inscription.
Alors on se voit là-bas.
17. Créer un résolveur d'inscription: Maintenant, dans la mutation d'inscription, supprimons ce code ici. Et la première chose à
faire est de créer un nouvel utilisateur. Donc utilisateur constant plutôt que d'
attendre le service utilisateur. Et il peut se le permettre si
les utilisateurs réduisent le service utilisateur. Ensuite, nous allons utiliser la méthode de création et transmettre l'entrée ou
l'entrée d'inscription. Et pour nous, il ne s'agit que de
l'argument d'entrée ici. Maintenant, le type de retour de
la mutation d'inscription est objet doté d'un
champ utilisateur avec le champ JWT. Nous devons donc
créer un jeton JWT. Et pour cela,
ouvrons notre terminal
et installons npm JSON Web Token. Et bien sûr, nous avons besoin des types, des types JSON Web Token. Et laisse-moi effacer ça,
fermer le terminal. Et ici, nous devons générer un jeton JWT à l'aide
du package JWT. Importez JWT à partir d'un jeton Web JSON. Vous savez comment
faire, nous devons utiliser JWT plutôt que la méthode de connexion. Ici. Nous allons transmettre la charge utile. Et cette fois, je vais
ajouter une charge utile avec un e-mail à partir de la saisie de cet e-mail et un identifiant
utilisateur à partir de l'identifiant utilisateur. Et nous avons besoin d'un jeton JWT. Nous devons donc créer un fichier de
longueur de point et y ajouter la variable de jeton
JWT. Donc, au
niveau du routeur de notre projet, créons un fichier. Et à l'intérieur, une clé JWT, et ajoutez des caractères aléatoires. Et puis enregistrez. Ensuite, nous avons besoin du
package qui
lira les fichiers pour nous dans
un projet TypeScript. Et ce sont les crochets. Donc npm install dot. Alors ça y est, c'est
sûr. Ne pas enregistrer le développement. Laisse-moi clarifier les choses maintenant. Fermez le terminal et
nous allons utiliser le point m qui se trouve
dans le fichier main.js. Donc, ici, j'importe
tout comme dans. À partir de là, nous allons utiliser dans le gothique
et appeler cette méthode. Et assurez-vous de l'
importer en haut de la
page pour toutes les
déclarations d'importation, puis de Enregistrer. Et ici, dans la méthode
bootstrap, nous allons vérifier si nous avons un processus qui se trouve dans le jeton
JWT ou non. Oui. Donc, si vous n'avez pas de clé GDB T ici, si vous ne l'avez pas, nous allons renvoyer
ou générer une nouvelle erreur. Et il y aura un
message indiquant base de données. Très bien, maintenant, enregistrons ceci, revenons ici, fermons
le fichier main.js et passons au processus dans
cette clé JWT. Nous devons donc ajouter un point d'exclamation ici car nous avons déjà vérifié
dans le fichier main.js. Sinon, nous n'avons pas
obtenu la clé DWT. Lorsque nous exécutons l'application, nous allons générer une erreur et nous ne démarrons pas l'API. Nous devons maintenant ajouter
un nouvel objet ici. Et nous ajouterons les dates d'
expiration dans la propriété. Et ici, nous pouvons
définir l'heure à laquelle nous voulons que ce
jeton JWT expire. Donc, dans mon cas, je veux faire expirer ce
jeton dans sept jours. Vous pouvez donc choisir
quand vous le souhaitez. Sauvegardons ça. Et bien sûr, nous pouvons ajouter des
jours comme celui-ci. Si vous survolez la propriété exposée
ici, vous constaterez que c'est sauf comme le temps en secondes ou avec juste quelques
chaînes comme celle-ci, deux jours ou 10 h, sept jours. Il existe de nombreuses
façons de définir l'heure ici. Maintenant, après avoir créé
le jeton JWT, nous devons renvoyer un objet
avec l'utilisateur et le JWT, et il sera
défini sur le jeton JWT. Maintenant, l'erreur a
disparu car nous
renvoyons la valeur
correcte ici. Et nous devons encore
vérifier si nous avons un utilisateur avec le même e-mail que celui qui existe
déjà
dans la base de données. Pour cela, nous devons
créer une nouvelle méthode
dans le service utilisateur. Et il s'appellera
Find One by email. Et nous allons recevoir
l'e-mail sous forme de chaîne. Ensuite, nous allons
renvoyer 08 et utiliser
le référentiel des utilisateurs trouver un en envoyant rapidement
un e-mail ici. Maintenant, sauvegardez ceci et
revenez aux résolveurs. Et ici, créez une nouvelle
constante et nommez-la, utilisateur
existant ou existant. Et ici, nous allons
utiliser le service utilisateur qui trouve un par e-mail et l'
e-mail à partir des entrées de cet e-mail. Et nous devons attendre ça. Et puis enregistrez. Et nous devons vérifier si
nous avons un utilisateur existant, puis nous devons
renvoyer une erreur. Et pour l'erreur, nous devons utiliser un type d'
erreur très
spécifique qui
provient de ou avec GraphQL. Et c'est un GraphQL. Et nous pouvons l'importer à
partir d'une transaction graphique. Oui, donc si vous n'avez pas
installé Graph ici, assurez-vous de l'installer et d'
installer également les types pour GraphQL. Et ici, nous
devons ajouter un message. Le message va donc
être que l'utilisateur existe déjà. Et nous pouvons simplement renvoyer un message ou ajouter d'autres configurations, comme l'extension
ou les extensions. Et ici, nous pouvons ajouter le
code de cette erreur. Donc, un autre objet
ici, Code property. Et je vais
renvoyer un code de demande erroné. Donc, si vous souhaitez
renvoyer des informations
sur cette erreur, comme peut-être les champs ou
le type d'erreur suivant. Vous pouvez ajouter tout cela dans l'
objet extensions ici, et il sera envoyé
au client. Bien sûr, si vous souhaitez
créer une erreur
personnalisée créez comme nous l'avons fait dans les deux
autres projets. Créez une
classe distincte pour son erreur. Et bien sûr, vous
devez toujours utiliser GraphQL ici pour créer ces classes. Mais ce n'est vraiment pas
obligatoire car nous avons déjà une classe
et nous pouvons l'utiliser chaque fois que nous
voulons générer une erreur. Et il sera analysé
au fur et à mesure que le graphe s'en occupera ou oui, nous n'avons pas besoin de créer
de nouvelles classes à partir de cela. Maintenant, c'est tout pour
la méthode d'inscription. Dans la vidéo suivante, nous allons
créer la connexion.
18. Créer un résolveur de connexion: Maintenant, nous ne pouvons pas travailler sur le
signe d'une mutation ici. Donc, les résolveurs,
parce que nous n'avons toujours pas défini le signe dans les
mutations, sont le schéma. Alors
faisons-le d'abord , puis revenons
aux résolveurs de la Terre. Juste ici. Définissons la mutation, créons le
site en mutation. Et nous aurons une entrée
de type, une entrée de connexion. Et d'ailleurs, nous
pouvons utiliser une autre
structure ici. Ainsi, plutôt que
d'ajouter un argument et l'heure
de cet argument, nous pouvons définir tous
les arguments ici, comme un e-mail de type chaîne. Et c'est obligatoire. Ajoutez ensuite une virgule et nous avons
besoin d'un mot de passe sous forme de chaîne. Oui, mais comme nous utilisons également
les types dans
nos résolveurs, dans notre service utilisateur, nous devons définir son
type d'entrée en tant qu'objet ici. Changeons donc cela pour
saisir une entrée de connexion, et celle-ci
sera obligatoire. Encore une fois, nous allons
renvoyer une réponse terrestre. Et bien sûr, c'est obligatoire. Maintenant, nous devons ajouter
la connexion ici, l'
entrée créée ici. Entrez et connectez-vous. Nous n'avons besoin que de l'
e-mail sous forme de chaîne, et il est acquis
avec le mot de passe en tant que chaîne obligatoire. Hein ? Maintenant, sauvegardons ceci
et ouvrons le terminal. Et nous devons
générer le schéma. Donc, npm run, génère originairement
le type du schéma. Très bien, fermez maintenant le terminal et fermez le fichier GraphQL à
points du schéma et revenez ici dans
les solveurs de l'auteur. Sous la connexion. Définissons le ou
sous l'inscription, définissons la méthode de connexion. Nous devrions obtenir une succession
pour cette méthode ici. Attends juste une seconde ici. Connectez-vous. Et si vous passez la souris dessus, vous constaterez que sine
n est de type résolveur. Nous avons donc généré
les types correctement. Voici donc la définition de l'
entrée actuelle et des contextes. Et comme je l'ai déjà dit, nous allons
parler des contextes et uniquement des prochaines vidéos. Oui, nous devons
donc vérifier si nous
avons un utilisateur avec cet e-mail
enregistré dans la base de données. Je vais donc copier
ces deux lignes ici à partir de la
méthode d'inscription et les coller ici. Et modifiez cela avec juste l'utilisateur. Ici. Si ce n'est pas le cas, si nous n'avions pas d'utilisateur, nous allons renvoyer
une longue erreur écrite. Donc voilà, faux, Cree Potentiels, outter et le code
toujours une mauvaise demande. Ensuite, nous devons
vérifier si les passe
contenus
dans l'entrée sont égaux au mot de passe dangereux
de la base de données utilisateur. Ajoutons donc une constante
et nommons-la correctement PWD, puis attendons la crypte B. Et nous devons l'importer. Donc, ce chien Alport classe corrompue à partir
des paquets de déchiffrement. Et ici, nous allons utiliser
la méthode de comparaison. Et cette méthode
accepte le buffer ou l'entrée
, puis le compare au mot de passe
acid. Oui. Entrez donc ici le mot de passe. Ensuite, nous obtiendrons le mot de passe
de danger à partir du mot de passe utilisateur. Mais dans notre cas, nous ne pouvons pas obtenir le
mot de passe de l'utilisateur. C'est parce que dans
l'entité utilisateur, nous avons utilisé le
canon de mots à la mode, sélectionnez faux. C'est pourquoi nous allons arriver
ici et définir ou non. Oui. Mais nous pouvons modifier ce
site, le service utilisateur, et à la place, ils en trouvent un par
e-mail qui l'a supprimé, trouvent un par méthode. Ici. Créons un générateur de requêtes. donc un générateur de requêtes à partir du référentiel utilisateur Créez donc un générateur de requêtes à partir du référentiel utilisateur. Et ici, nous allons
déclarer une variable
et lui donner le nom d'utilisateur. Et équivalent au
générateur de requêtes. Ici. Ajoutez une idée pour l'utilisateur, puis nous utiliserons une méthode pour sélectionner le mot de passe utilisateur. Voici donc le mot de passe utilisateur,
maintenant la requête. Mais il existe une méthode
qui aide à créer des requêtes
SQL en ajoutant simplement d'
autres méthodes comme celle-ci. Oui, nous allons donc créer dégénérer une
requête de suite ici en utilisant le Query Builder pour
sélectionner le mot de passe utilisateur. Ensuite, nous allons trouver ou sélectionner un utilisateur pour lequel
l' e-mail est égal à un e-mail. Nous allons définir ici
la variable email. Donc, ce qui se passe ici,
c'est que nous allons vérifier si l'e-mail est égal
à cette variable, oui. Et pour définir les variables
dans cette requête ici, nous ajoutons les deux-points puis
le nom de la variable. Et puis, dans le
deuxième argument, nous avons un objet contenant les valeurs de cette
variable, et il doit porter le
même nom que celui que nous avons écrit ici. C'est pourquoi, lorsque nous exécuterons
le générateur de requêtes ici, celui-ci sera remplacé par email equals, puis
par e-mail de l'utilisateur. Maintenant, nous avons besoin d'une
autre méthode pour obtenir un utilisateur. Et si vous passez la souris sur l'utilisateur maintenant, vous trouverez cet utilisateur sous la forme d'une promesse qui vous renverra ou
non un utilisateur. Par conséquent, nous
devons attendre ici, et cette fois, nous
aurons un utilisateur ou non. Dans ce cas, nous
allons renvoyer l'utilisateur et enregistrer
le service utilisateur. Retournez ici. Ou en fait, revenons
au service utilisateur. Et là, j'ai oublié de mentionner que nous devrions ajouter
une sélection ici. Oui, ce sera
la
sélection principale et nous allons sélectionner le document utilisateur
ou toutes les colonnes
à la place
du document utilisateur. Ensuite, nous ajouterons une sélection dans laquelle nous
utiliserons le mot de passe. Ensuite, nous allons filtrer ici, puis renvoyer l'
utilisateur avec le mot de passe. Malheureusement,
la force de sélection
ne masque ici que le mot
de passe des méthodes de recherche. Alors trouvez-en un ou
trouvez par quelque chose. Oui, mais ça ne
cache pas le mot de passe. Lorsque nous enregistrons l'utilisateur ici
ou que nous enregistrons une nouvelle entité. Par conséquent, nous devons créer une constante ici
dans la méthode create. Créez une constante
contenant l'utilisateur du service, puis créez une autre
méthode Find ici. Et recherchez l'
utilisateur avec l'identifiant. Oui, mais ce sera
une perte de temps, surtout si vous
travaillez avec GraphQL. Parce qu'avec GraphQL,
nous pouvons masquer des mots de passe ou n'importe quoi
en supprimant simplement les champs ici. Donc, pour le mot de passe, nous pouvons
supprimer le champ du mot de passe. Et puis dans
la réponse désactivée, dans l'utilisateur, nous
n'obtiendrons pas le mot de passe. C'est ainsi que nous masquons les
informations d'identification à l'aide de GraphQL. Mais ici, je voulais juste vous
montrer comment obtenir un champ de hauteur à partir de la base de données à l'aide du
créateur de requêtes si vous n'utilisez pas GraphQL. Je vais donc laisser ce
code comme ceci juste pour que vous vous souveniez comment
obtenir un tunnel haut, comme le mot de passe
et la triste entité utilisateur Je vais supprimer le select false ici
parce que je ne
veux pas changer ou écrire
le même code à chaque fois que
je veux obtenir l'entité. Et j'ajouterai un niveau 2
commun. Pour l'indiquer, vous ne pouvez utiliser cette approche
que lorsque vous êtes masqué. Donc, ici, uniquement si l'entité que Carlin et vous avez
sélectionné est définie sur false. Enregistrez maintenant le service utilisateur fermez ces deux fichiers
et revenez ici. Et cela permet de continuer très rapidement
avec la méthode de connexion. Maintenant, nous devons
vérifier si nous n'avions pas ou si nous n'avons pas obtenu
le bon mot de passe, puis nous renverrons une erreur. Et là, il me manque l'air, corrige ou je vois et j'entends, lance une nouvelle erreur de Graph Girl. Et ce sera
le même message que votre
identifiant, faux identifiant. Et la même extension. Alors laissez-moi copier ceci. Et ici, je vais
copier l'extension. Ensuite, nous devons régénérer le jeton JWT, puis renvoyer
l'utilisateur avec le JWT. Je vais donc le copier
et le coller ici. L'utilisateur va maintenant être
renvoyé avec le mot de passe. Mais comme nous l'avons modifié
dans le schéma, nous ne reviendrons pas ou
l'engrenage du graphe ne
sélectionnera pas le mot de passe dans l'instruction
de retour des mutations ici. Maintenant, bien sûr, vous devez
ouvrir votre terminal et exécuter npm run degenerate car
nous avons mis à jour le schéma. Alors allons-y. Npm run generate. Et c'est tout. Nous avons terminé de travailler sur
la méthode de connexion.
19. travailler avec le contexte graphql: Nous allons maintenant
créer une requête qui renverra l'
adresse e-mail et le nom d'utilisateur. Et encore une fois, nous allons
partir du schéma. Est-ce que GraphQL et Crea créent
une nouvelle requête et la
nomment utilisateur actuel ? Et ici, nous allons
renvoyer une charge utile JWT. Nous devons maintenant définir ce type. Copiez donc le nom JWT
et créez ici le type, puis JWT, disparaissez et citez-le. Nous aurons l'
e-mail de type string, et nous aurons l'identifiant
utilisateur de type int. Et les deux sont obligatoires. Maintenant, sauvegardons ceci, fermons le schéma de GraphQL et nous devons
générer les types. Exécutez npm, exécutez, générez et fermez le terminal. Revenez aux résolveurs de l'auteur. Et ici, dans la requête, supprimons la
méthode get d'ici. Et la méthode utilisateur actuelle. En l'entendant. Parent, nous avons besoin
des informations et des contextes. Très bien, nous avons maintenant
une erreur car nous
n'avons pas ajouté de variable d'entrée
à la requête utilisateur actuelle, comme si nous n'avions pas
attribué la mutation, nous n'aurons
donc pas
d'argument d'entrée ici. Supprimons donc ceci et remplaçons
le par notre x comme ceci. Et juste pour qu'
il soit clair que nous n'
avons aucun argument, je vais le
remplacer par un objet vide. Très bien,
nous allons maintenant extraire la charge utile JWT
du jeton JWT. Mais nous avions l'habitude d'ajouter
cette logique dans un intergiciel, puis de l'utiliser dans d'autres routeurs. Ensuite, obtenez un objet à partir des requêtes contenant
la charge utile de l'utilisateur. Mais c'est bien sûr
dans une API RESTful. Mais comme nous utilisons
Express avec GraphQL, nous pouvons faire la même chose. Nous pouvons ajouter. Nous pouvons utiliser un Create
Image, puis utiliser la méthode 2s pour
appliquer le Midwest ici. Et puis nous obtiendrons le, nous pourrons extraire la
charge utile JWT du jeton JWT. Mais nous pouvons implémenter le même processus avec le serveur
Apollo en ajoutant un contexte qui contiendra la demande et
les charges utiles JWT. Donc, ici, disons le
serveur Apollo dans son contexte. Et ce
sera une fonction qui renverra un objet. Maintenant, avant de commencer à travailler
sur cette fonction, nous devons ajouter une nouvelle interface
et la nommer contextes. Voici donc l'interface d'exportation,
puis mon contexte. Nous devons étendre le contenu de l'Express afin de pouvoir
accéder à la demande. Et ici, nous allons ajouter
nos propriétés personnalisées. Mais d'abord, nous devons
importer les contextes Express depuis le serveur Apollo. Voici donc le
contexte d'Airport Express à partir d'une photo
Server Express. Maintenant, voici notre
première propriété personnalisée, qui est l'utilisateur actuel. Et ce sera une charge utile de
type T, W T. Et la charge utile DWT est importée à partir des types incinérés. Assurez-vous donc de l'importer depuis
ce chemin ici. Ensuite, nous devons ajouter
une autre propriété, qui est la propriété
autorisée. Et avec cette propriété, nous pouvons vérifier si nous avons un utilisateur
autorisé ou non. Cette propriété va donc
être de type booléen. Et sauvegardez ça. Retournez ici. Et nous devons ajouter l' interface
Mike Contexts
au serveur Apollo. vais donc renvoyer le serveur Apollo avec mes contextes de
type, mes contextes. Très bien, maintenant, revenons
à cette méthode ici. Et maintenant, nous pouvons extraire. À partir du dysfonctionnement,
extrayez la demande et la réponse car nous avons
étendu les contextes Express. Et ici, créons une
constante et nommons la charge utile, puis utilisons les
paquets DWT de DWT, nous devons les importer. Alors allons-y. Important, JWT de Jason revient ici, CWT point
verify pour vérifier le jeton. Et cette fois, nous allons obtenir
le jeton, non pas à partir de la session, mais à partir des en-têtes. Nous allons donc utiliser la
charge utile de la requête ou les attaches. Assurez-vous de sélectionner
des en-têtes, sans attache. Ensuite, nous allons obtenir
le jeton à partir de l'en-tête
d'autorisation. Oui. Donc, celui de Heather peut être non. Ajoutons-y donc un point d'
interrogation. Et maintenant, nous devons transmettre
la clé secrète JWT. Je peux donc l'obtenir
en utilisant la touche DWT et en ajoutant
un point d'exclamation. Nous pouvons donc dire à TypeScript
que ce n'est pas nul. Et maintenant, nous devons renvoyer
cette charge utile ici. Ayez donc une commande ici, car il semble
que la demande puisse également être nouvelle ou indéfinie. Ajoutons-y donc un point d'
interrogation. Ou vérifions simplement si nous n'avons pas
reçu de demande. Oui, nous allons rendre un objet et nous
reviendrons ici dans une seconde. Définissons maintenant la propriété utilisateur
actuelle et attribuons-lui la charge utile. Ensuite, nous
renverrons ou transmettrons également la demande
aux résolveurs. Ensuite, nous aurons la propriété
autorisée, et la
propriété autorisée est une propriété booléenne. Nous allons donc vérifier si vous
avez une charge utile ou non. Donc, si vous n'avez pas effectué de paiement cela signifie que l'utilisateur n'
est pas autorisé. Donc, pour cela, je vais
utiliser une syntaxe spéciale. Donc, nos deux points d'exclamation,
puis Abby, ont payé. Ainsi, si la charge utile est
nulle ou indéfinie, le premier point d'exclamation
renverra la valeur true. Ensuite, le deuxième
point d'exclamation
renverra l'opposé
de vrai, qui est faux. Et puis ils ont autorisé, ça va être réglé sur
faux, ce qui signifie que l'utilisateur n'
est pas autorisé parce que
nous avons un nul, un pilote. Maintenant, si nous n'avions pas
de demande, c'est un problème pour nous car nous ne pouvons pas
extraire le jeton JWT. Nous allons donc envoyer un
sur le même objet mais avec le sélecteur coréen défini
sur null et la demande, bien
sûr, et l'
autorisation sur false. Nous devons le rendre. Bien, maintenant, supprimons
les points d'interrogation d'ici. Et en fait, ici,
nous devons vérifier si nous n'
avons pas reçu ou si nous n'avions pas d'en-tête de demande d'autorisation ici, puis nous allons simplement
renvoyer cet objet. Sinon, nous allons
extraire la charge utile et envoyer la propriété requise. Maintenant, permettez-moi d'ajuster un peu ce
code pour ce faire et d'enregistrer ce fichier. Fermez-le ensuite et
revenez au résolveur
utilisateur coréen ou à la requête ici. Et nous allons vérifier si la propriété est autorisée
dans le contexte. Vrai ou faux. Oui. Donc, si la
propriété autorisée l'est ici. Et nous n'obtenons pas l'
autorisation du contexte. C'est parce que nous devons
mettre à jour la chaîne de code ici. Oui, et mettez à jour les
types de résultats. Nous devons donc spécifier le type de contexte et le
dire dans la configuration ici. Et dans le même niveau d'
indentation, contextes, type ou contextes, tapez par
type et spécifiez le chemin ou le fichier qui
contient notre contexte. Dans notre cas, mes contextes
existent-ils dans le fichier du module. Assurez-vous donc d'abord d'exporter
l'interface des contextes Mike et de venir ici et d'ajouter la naissance en fonction de
ces dossiers générés. Donc, en fonction du dossier
généré, du module ou
du type de résolveur existant à du type de résolveur côté du dossier
généré. Le fichier du module se trouve un
niveau en dehors, puis le module. Et nous devons sélectionner
l'interface. Nous allons donc ajouter un hashtag ici et ajouter le nom
des contextes. Donc mes contextes. Et dans ce cas, nous sélectionnons a, a, une interface
ou
une variable exportée à partir du fichier en utilisant
une syntaxe YAML. Fermons maintenant le fichier de configuration
co-gen et ouvrons le terminal. Ensuite, nous devons exécuter
les commandes du générateur. Donc, npm run generate, puis nous obtiendrons notre
contexte de type, mon contexte. Oui. Alors attendons. À l'heure actuelle. Si vous passez la souris sur des contextes, vous devriez avoir saisi les
contextes du vélo ici. Maintenant, permettez-moi de fermer le terminal et l'autorisation est
de type booléen. Nous allons donc vérifier si
l'utilisateur n'est pas autorisé, puis nous allons
renvoyer une erreur non autorisée. Throat savait donc que GraphQL
et MS n'est pas autorisé. Et nous devons ajouter une extension. Prolongation. Ajoutez ensuite le code. Et ici, nous allons ajouter le code. Non autorisé. Ça va ? Maintenant, si nous avons autorisé
cet utilisateur ou si nous allons revenir du
contexte, l'utilisateur actuel. Maintenant, économisons. L'utilisateur actuel est de type G. La charge utile adjointe contient
l'e-mail et l'identifiant utilisateur. Le nom du type est simplement
lié à GraphQL. Mais dans le
schéma GraphQL ou dans une réponse, nous n'obtiendrons que
l'e-mail et l'identifiant utilisateur. Très bien, maintenant, sauvegardons ça. Et pour tester tous
ces résolveurs ici, nous devons disposer d'une base de données
fonctionnelle. Dans les prochaines vidéos,
nous allons donc apprendre
à utiliser Joker, bien sûr, à installer Docker, puis à utiliser Docker pour installer la base de données Postgres et l'exécuter dans notre système local.
20. Qu'est-ce que Docker: Docker découpe un système Linux en
fonctionnement en petits conteneurs,
qui constituent son propre petit monde
avec ses propres programmes
et tout ce qui lui est propre, le
tout isolé de tout le reste. Ces conteneurs sont
conçus pour être portables afin de pouvoir être déplacés
d'un endroit à un autre. Et Docker se charge
d'acheminer ces conteneurs vers
et depuis vos systèmes. Maintenant, qu'est-ce que le contenant ? Vous savez, lorsque vous créez
quelque chose avec, par exemple un OTS, puis que vous
envoyez votre code dans GitHub et que
quelqu'un d'autre
essaie de récupérer et d'exécuter votre code dans
son système local, mais cela ne fonctionnait pas pour lui. Et puis il pensera
que votre code est nul. Et vous pensez peut-être aussi que
vous n'êtes pas un bon développeur. Mais parfois, ce n'est pas le
cas car vos
applications Node.JS nécessitent des logiciels
très spécifiques
et un environnement unique pour fonctionner. Et ces exigences
n'existent que dans
votre système local, où vous vous trouvez,
où vous avez développé votre application Node.JS. Par exemple, si vous
utilisez Linux au lieu de Windows ou si vous avez une
ancienne version de nœuds, oui, toutes ces variables ne peuvent pas être les mêmes sur tous
les systèmes. Par conséquent, Docker a introduit ce que l'
on appelle un conteneur. Un conteneur est une
unité logicielle standardisée qui permet aux développeurs de s' y rendre
facilement depuis
son environnement. Vous pouvez donc développer, par exemple votre application Node.JS,
créer un conteneur autour celle-ci et la transmettre à
Docker Hub sous forme d'image. Ensuite, n'importe
qui peut extraire cette image et l'exécuter dans
son propre système local. Dans ce cas, votre application
NodeJS s'
exécutera dans le même environnement
que sur votre système local.
21. Installer docker Linux: Maintenant, pour démarrer Docker sur votre fenêtre ou sur un
système Linux en général, vous devez
suivre quelques étapes. Alors, passez aux étiquettes plus sombres. Et vous pouvez utiliser ce
chemin ici ou cette URL. Et vous pouvez peut-être effectuer une
recherche sur Google pour installer
le moteur Docker sur votre pinto, car URL peuvent être modifiées
à l'avenir. Maintenant, la première chose
à faire ici est de vous assurer que vous n'
avez pas d'ancienne
version de Docker. En exécutant cette commande ici, vous pouvez supprimer toutes les versions
obsolètes. Maintenant, l'étape suivante consiste à mettre à jour
vos packages APT. Ensuite, je vais commencer par
quelques mendiants et voir si cela sera
utilisé dans les prochaines étapes. Oui, alors vous
devez exécuter ces commandes pour indiquer à votre système
que vous pouvez l'utiliser. Le logiciel provient
du Docker Engine. Ensuite, vous devez exécuter cette commande pour
configurer votre référentiel. Et si
nous devons ajouter notre référentiel ou
configurer un référentiel connecté au
Docker Engine, c'est parce que nous
allons extraire des images
de Docker Hub. Et parfois, nous devons envoyer des images que
nous avons créées vers le Docker Hub. Nous avions donc besoin d'aéroports
comme ça. C'est similaire aux référentiels
de GitHub. Oui. L'étape suivante consiste à
installer le moteur Docker. Après avoir défini
leur référentiel. Bien entendu, vous devez à nouveau
mettre à jour vos packages. Et si vous avez des
erreurs, exécutez ces commandes. Enfin, vous pouvez installer Docker en
exécutant cette commande. Ensuite, si vous
souhaitez vérifier si vous avez correctement
installé Docker, vous pouvez exécuter une image
qui existait par défaut avec Docker
appelée kilowatt. Exécutez donc cette commande, sudo docker run hello-world, et vous devriez obtenir une chaîne
avec HelloWorld.
22. Images dans des conteneurs: Maintenant que
Docker est installé et que nous avons parlé un peu
de ce qu'est Docker, essayons de l'utiliser. Ainsi, avec Docker, tout
commence par une image. Une image est un
fichier qui constitue partie suffisante du système
d'exploitation pour faire ce que vous devez faire. Désormais, la commande permettant d'
examiner vos images Docker est simplement des images Docker. Vous pouvez voir ici
que j'ai beaucoup d'
images et de choses qui se passent ici parce que j'avais l'habitude de
se produire tout le temps. Et pour vous, vous avez peut-être des images comme celles que vous avez
vues ou HelloWorld. Maintenant, son image a un
nom et une version, la dernière version du
vélo ou
quelque chose comme ça. Et son image a également un identifiant. Et ici, nous pouvons savoir quand
cette image a été créée. Et ici, vous pouvez voir
la taille de cette image. Maintenant, prenons une image et exécutons-la dans le
conteneur à l'aide de Docker. Permettez-moi d'effacer ce terminal,
puis de lancer right docker. Exécutez la commande. Maintenant, cette commande prend une
image et la transforme en un conteneur actif contenant un processus qui
fait quelque chose. Maintenant, après l'exécution de Docker, je vais spécifier l'
image qu'ils souhaitent utiliser. Et pour moi, je vais
utiliser les personnes que j'ai visitées. Et pour vous, si vous
ne l'avez pas trouvé, vous
l'avez installé par
défaut dans votre joker. Ne vous inquiétez pas, car en
exécutant cette commande, Docker essaiera d'
attirer l'humain vers
une image à l'aide de la dernière
version du Docker Hub. Bien entendu, vous devez disposer d'une connexion Internet
pour ce faire. Maintenant, je n'ai toujours pas terminé
cette commande ici. Alors Docker Run, vous y êtes déjà allé. Ensuite, nous avons dit
que nous allions
exécuter un processus dans cette image. Exécutons donc le shell
bash parce que je veux exécuter certaines
commandes que vous avez consultées avec le terminal. Et pour cela,
nous avons également besoin d'un drapeau pour interagir
avec le terminal. Et le drapeau est le drapeau D. Donc D signifie
terminal et I signifie interactif,
terminal et directive. Alors tu es allée à Bash. Et maintenant, exécutons ce
schéma pour vous. Si vous n'y êtes pas déjà allé, vous verrez un processus de
téléchargement. Très bien, nous sommes à l'intérieur
de l'image Ubunto. Maintenant, si je jette un coup d'œil ici, je constaterai que nous sommes
à l'intérieur de l' environnement que
vous avez connu. Et juste pour être
sûr d'exécuter cette commande pour jeter un œil à ce fichier LSB Dash Release. Et nous devrions obtenir
la version que vous allez avoir ici, la version 20 et
l'identifiant de distribution. Vous allez maintenant quitter
cette image. Vous pouvez écrire exit comme ceci
ou Control D le fait pour exit. Maintenant, pour voir
la dernière image sortie, nous pouvons ouvrir un nouveau terminal ici et Docker PS
puis Dash Latest. Donc, si vous exécutez juste
ps, vous trouverez que vous obtiendrez toutes
les images en cours d'exécution. Et avec L, vous pouvez obtenir
la dernière image éditée. Si vous exécutez cette commande,
vous constaterez que l'image est celle que vous avez visitée. Et vous trouverez ici la commande qui
exécutait cette image. Et bien sûr, où
le crée-t-il ? Et il est sorti il y a
environ 4 minutes. Oui. Et ce n'est pas le nom de
ce conteneur, pas l'image. Ce conteneur fait donc
passer l'urbain à l'image et gère
le panier. Oui. Et il a été créé
il y a 6 minutes et quitté il y a 4 minutes. Et c'est l'idée
du contenant. Et ils ont prononcé le nom
du contenant. Et d'ailleurs, ce nom est généré
aléatoirement par Docker. Revenons maintenant
ici et exécutons le, vous êtes revenu à l'image
avec le shell bash. Et à l'intérieur de cela,
vous avez vu une image. Créons un nouveau fichier à
l'aide de la commande tactile
et nommons-le mon fichier. Jetez un œil ici et
nous trouverons mon dossier. Alors quittons ça. Ou je laisse ce conteneur s'
exécuter et je reviens ici, puis j'exécute
la même commande, docker, run TI pour
Terminal Interactive. Ensuite, vous avez consulté
et exécuté le shell Bash. Nous exécutons donc
la même image avec le même drapeau dans
le même processus. Et ici, si nous y jetons un coup d'œil, nous ne trouverons pas le fichier
qui a été créé ici. Son conteneur
exécute donc une image et n'est pas affecté par les autres conteneurs qui
exécutent la même image. Donc, lorsque nous créons un fichier ici, cela
ne signifie pas que
nous allons obtenir le même fichier dans ce conteneur qui
exécute la même image. Son contenant est donc
isolé l'un de l'autre. Même s'ils
exécutent tous les deux la même image, vous pouvez les considérer comme deux ordinateurs exécutant la même
version que vous avez visitée.
23. conteneurs à images: Nous pouvons maintenant voir que nous sommes
passés d'une image à un conteneur
en cours d'exécution. Et lorsque nous démarrons un conteneur, le conteneur est toujours là.
Il n'a pas été supprimé. Je peux donc regarder le dernier conteneur
sorti avec une commande docker ps. Mais bien sûr, nous avons besoin du drapeau Dash L pour obtenir le
dernier conteneur arrêté. Vous pouvez donc voir ici que j'
ai un conteneur qui
fonctionnait il y a un instant. Et vous pouvez consulter toutes
les informations concernant ce conteneur ici. Maintenant, disons que j'ai
un conteneur arrêté. Je suis parti d'une image de base. Ion a lancé mon propre logiciel. J'ai un conteneur sur lequel mon logiciel est installé. À l'avenir, je souhaite utiliser le
même conteneur contenant mes propres logiciels
,
ou peut-être le partager
avec la communauté. Pour ce faire, nous devons utiliser la commande docker
commit qui prend des conteneurs et en
fait des images. Donc, pour utiliser le commit docker, créons d'abord un nouveau
conteneur. Mettons les choses au clair. Et un. Vous y êtes allé, bien
sûr, avec l'indicateur TI,
puis vous avez accédé à la commande par lots et vous l'avez
exécutée. Maintenant, à l'intérieur de ce conteneur, nous allons créer un fichier, et nous devrons utiliser ce fichier à l'avenir
avec ce conteneur. Nous allons donc
créer une image à partir de ce conteneur à l'aide de la commande tactile, créer un fichier et le nommer comme secret. Nous avons notre dossier ici. Quittons ce conteneur avec Control D ou écrivons
simplement exit. Et puis prenons l'idée de ce conteneur
en exécutant docker ps dash L. Ensuite, nous avons ici
l'idée de ce conteneur. Copions donc cet identifiant. Ensuite, utilisons la commande
docker commit
et collons l'identifiant le plus sombre ou
l'identifiant du conteneur ici, puis exécutons la commande docker
commit. Maintenant, nous obtiendrions une image
de ce conteneur. Et c'est l'
idée de cette image. Mais utiliser un identifiant long comme celui-ci n'est pas une bonne chose
car vous pouvez perdre cet identifiant ou peut-être avoir du
mal à exécuter des commandes en utilisant
cette longue chaîne. Donc, ce que je vais
faire ensuite, c'est étiqueter cette image avec
un nom lisible par l'homme. Et pour ce faire, nous
n'utilisons pas le tag flag. Ensuite, nous ajoutons l'identifiant
de cette image entre les deux points à la fin de cette
chaîne et nous le collons ici. Ensuite, choisissez un
nom pour cette image. Alors imaginez quoi, par exemple et exécutez la commande Docker. Maintenant, si nous voulons vérifier
si vous avez une image avec le tiret ou le
soulignement d'un nom, vous pouvez exécuter Docker images,
puis rechercher le nom de
l'image ici. Vous pouvez le trouver ici. Nous avons donc l'image de soulignement 1, et voici l'identifiant. Et il a été créé
il y a quelques minutes. C'est ainsi que nous pouvons créer des
images à partir de conteneurs. Il existe désormais un autre moyen
de valider des images
plutôt que d'utiliser la
commande commit. Et c'est de la perspicacité. Et tout d'abord, créons un conteneur Docker et prenons l'idée
de ce conteneur. Ensuite, nous allons utiliser le
docker commit d'une autre manière. Nous allons donc créer
un fichier comme le mien. Et sortons à nouveau. Ensuite, nous allons
vérifier ou nous faire une idée
de ce conteneur
Docker. Et maintenant, nous pouvons prendre le
nom du conteneur. Ici, un nom lisible par l'homme, copiez-le, puis exécutez docker ,
commit, puis le nom
du conteneur, puis le nom de la nouvelle image que
vous souhaitez créer. Et cette fois, je vais
choisir l'image 2. Nous exécutons maintenant cette commande. Nous obtiendrions le même
résultat qu'avant. Mais si vous exécutez des images
Docker maintenant, vous pouvez trouver une image à présenter dans notre référentiel Docker
local.
24. exécuter la base de données postgres avec docker: Nous allons maintenant en savoir
plus sur Docker
et, en même
temps,
exécuter notre base de données Postgres. Et pour cela, nous devons extraire l'
image SQL postgres de Docker. Pour ce faire, nous
devons exécuter docker, pull. Puis le nom de l'
image qui est Postgres. Vous pouvez ajouter deux points
, puis la dernière balise. Mais par défaut, installez la dernière version. Maintenant, je ne vais pas exécuter
cette commande car j'ai déjà cette image
dans mon système local. Alors maintenant, je vais
utiliser la
commande docker run pour exécuter l'image
postgres. Bien sûr, avec le drapeau DI
ici et l'image postgres. Maintenant, nous n'allons pas
exécuter cette commande. Prenez ceci parce que nous
devons ajouter des configurations. Et cette fois, je
souhaite ajouter un nom personnalisé
à mon conteneur. Et pour cela, nous devons utiliser le drapeau nommé sur le bureau, puis choisir un nom similaire
à celui de haut. Souligner. Les deux stressent. Maintenant, pour établir
une connexion à la base de données
Postgres, nous devons exposer un port
et Postgres
utilise nativement le port 5432 pour
accepter les connexions. Nous devons donc exposer
ce port depuis le conteneur à l'aide
du drapeau Dash P. Et maintenant, nous devons mapper ce port Postgres avec un
port provenant du conteneur. Et je vais choisir un 545
5 v et ajouter deux points ici. Maintenant, vous n'avez probablement pas compris de quoi je
parle ici. C'est pourquoi j'ai préparé
un schéma ici pour simplifier l'idée
d'exposer des publications. Nous avons donc ici le Postgres, applications
Postgres ou le conteneur en verre de
sortie. Permettez-moi donc de changer le
nom ici chez Postgres. Et ce conteneur contient une
image. Cette image est donc
l'image postgres. Et Postgres
utilise nativement le port 5432. Mais nous ne pouvons pas connecter
une application à cette
image Postgres à partir du port 5432. Lorsque nous exécutons cette image
depuis le conteneur. Parce que, comme vous le savez, les
conteneurs sont isolés les
uns des autres et
du système local. Cette approche ne fonctionnera donc pas. Nous devons donc
utiliser une autre méthode, qui consiste à exposer une autre carte du conteneur et à
mapper ce port au port Postgres ou à l'image qui s'
exécute dans ce conteneur. Ensuite, pour nous connecter
à la base de données Postgres, nous devons nous connecter à l'hôte
local colon 5455. Nous devons donc nous connecter
au conteneur, et non à l'image elle-même. Maintenant, si vous en avez
plusieurs, vous pouvez bien sûr
les connecter au même
conteneur qui
exécute l' image postgres. Parce qu'ici, nous
utilisons localhost. Mais bien entendu, il n'est pas
recommandé d'utiliser la même base de données avec
d'autres applications car vous risquez de perdre des données et de détruire vos
tables de base de données, par exemple si l'application 1 enregistre un utilisateur dans la base de données
avec un e-mail a, alors en même temps,
nous avons également l'application, enregistre également un utilisateur
avec le même e-mail. Dans ce cas, vous
aurez à la place de votre base de données des utilisateurs
ayant le même e-mail, même si
des validations sont en cours d'exécution
dans vos applications, cela n'empêche pas qu'
une telle erreur se produise. Vous devez donc
créer un autre conteneur
avec la même image. Mais cette fois, vous
devez nommer ce conteneur avec un autre nom, puis
utiliser un autre port ici. Mais bien sûr, vous conserverez le même port pour
l'image postgres. Nous avons donc changé le nom en, jusqu'à et ici l'icône
Postgres. Nous avons donc l'
image Postgres ici et vous devez modifier ce port. Sinon, vous ne pouvez pas vous
connecter au conteneur, ni même
créer ce conteneur car vous
utilisez le même port dans un autre conteneur ici. Je vais donc simplement le changer en 5456. Et puis laisse-moi supprimer ça. L'outdo va se connecter à cette adresse, à ce conteneur. Et c'est ainsi que vous pouvez avoir, exemple, si vous créez
un microservice, c'est la bonne approche
pour vous connecter à une base de données. application doit donc avoir ses propres conteneurs qui
exécutent la base de données. Maintenant, je ne sais pas pourquoi je fais défiler l'écran de haut en bas
encore et encore comme ça, mais ignorons cela
et revenons ici dans notre terminal pour terminer
le conteneur Postgres de l'application. Nous avons donc nos articles ici. Maintenant. Nous devons définir certaines variables d'
environnement. Et il est nécessaire pour exécuter Postgres ou pour
se connecter à Postgres. Maintenant, ces
variables d'environnement sont également définies ici. Nous devons donc définir les mêmes informations
comme le nom d'utilisateur, le mot de passe, le port, et nous avons
changé le port 25455. Maintenant, changeons cela ici. Et le ressort,
le terminal ici, et essayez de copier les
mêmes informations. Maintenant, pour ajouter a, une variable d'
environnement, nous devons utiliser l'indicateur
dice e
, puis nommer la première variable. Et la première variable
est la poutre Post. Et tout doit être en majuscules. Maintenant, utilisateur de soulignement de Postgres. Il doit être le même
que le nom d'utilisateur ici. Ce sera donc égal à admin. Et pour définir une autre variable d'
environnement, nous devons utiliser à nouveau
l'indicateur Dash G, puis écrire le mot de passe
Postgres. Encore une fois, tout en majuscules. Ensuite, le mot de passe est le même mot de passe dans
la source de données de l'application. Le mot de passe est donc admin et la dernière
variable d'environnement est le nom de la base de données. Encore une fois, Dicey, puis Postgres. Donc c'est très grossier. Soulignez ensuite la base de données pour la base de données. Et le
nom de la base de données de base de données est principal. Minuscules. Il doit s'agir du même
nom que celui présenté ici. Bien entendu, le nom d'hôte
est local car ce conteneur va
fonctionner dans notre système local. Maintenant, exécutons ce conteneur
et attendons le résultat. Nous y voilà. Nous avons une connexion
en cours ici. Et ces informations
sont liées à Postgres. Nous établissons donc une nouvelle
connexion à la base de données. Et voilà, nous avons système
de base de données prêt
à accepter les connexions.
25. Tester le point final Graphql: Maintenant, pour que notre application se connecte
à la base de données
Postgres, nous devons initier la source de données de l'application
dans module.js fall. Donc, à côté de cela,
importons d'abord la source de données de l'application. Source de données. À partir d'une source de données. C'est à l'intérieur de celles-ci que démarre Apollo, et dès le début, nous devons attendre l'initialisation de la source de
données. Maintenant, la
méthode d'initialisation va se
connecter à la base de données
Postgres et prendre toutes nos entités et les
enregistrer en tant que tables de base de données. Et maintenant, avant de tester l'API, nous devons corriger quelque chose
et étudier le contexte ici. Donc, si nous avons un jeton JWT
valide, ils vérifient que la méthode
va échouer. Et en cas d'échec, nous ne pourrons pas nous connecter
au point de terminaison GraphQL. Et nous ne pourrons pas utiliser résolveurs qui ne nécessitent pas d'authentification, car la
méthode va générer une erreur et détruire l'ensemble de
notre application. Donc, ce que je vais
faire, c'est placer la méthode vérifiée
dans un bloc try catch. De cette façon,
nous pouvons empêcher que les erreurs
provenant de la méthode de vérification ne soient renvoyées en dehors de
la méthode contextuelle ici. Donc, la première chose
que je vais faire est de créer une variable
principale ici. Supprimez ensuite la
constante d'ici, puis copiez tout
ceci, chat ou ceci, et créez le bloc try
catch, catch. Alors, ici, essayez de détecter l'erreur. Ensuite, en gros, une
charge utile avec la méthode de vérification. Et si nous échouons ici, nous allons détecter l'
erreur dans le catch block. Mais nous n'allons pas
générer l'erreur ici,
car dans
ce cas, nous allons faire la même chose que la
méthode de vérification. Donc, ici, je vais régler
la charge utile sur no. Maintenant, si nous n'avons pas obtenu
le jeton d'autorisation, ils vérifient que
la méthode
va échouer et que
la charge utile sera définie sur Non, Yeah. Et la propriété autorisée
va être définie sur false. Nous n'avons donc pas besoin de la déclaration
if ici. Et lorsque nous n'avons pas
le jeton d'autorisation, nous allons transmettre
une chaîne vide et la méthode de vérification échouera de toute façon. Maintenant, la raison pour laquelle
nous faisons cela et que nous utilisions l'instruction
if ici, c'est parce que la méthode
verify n'
accepte que les chaînes sous forme de jeton, n'accepte pas les types indéfinis
ou nuls ici. Donc, si vous n'
aviez pas de théorisation, nous allons transmettre une chaîne. De cette façon, nous pouvons accéder à nos résolveurs même si
nous n'avons pas reçu de jeton. Maintenant, sauvegardons ceci
et ouvrons le terminal. Enfin, testons
notre point de terminaison GraphQL. Alors ici, laissez-moi développer cela
et exécuter npm, run, start. Et avant d'exécuter cette commande, nous devons modifier quelque chose au lieu du fichier adjacent
de Beggar. Nous utilisons donc le nœud
tiret, le tiret ici, mais cette commande
ne surveille pas
les modifications apportées
aux fichiers TypeScript. Et nous devons ajouter la
montre-drapeau comme celle-ci. Mais dans ce cas, faut ajouter qu'un et psi. Parce que si nous utilisons
deux signes et ici, nous attendrons que
cette commande soit exécutée et finisse de s'exécuter, puis nous exécuterons
la commande node. Mais le mode montre
ne se termine pas ici, non, il n'a pas de n. Oui,
c' est pourquoi nous l'
appelons mode montre, Oui. Et dans ce cas, nous n'exécuterons pas
cette commande. Nous devons donc supprimer cela
et n'utiliser qu'un et un sinus. Dans ce cas, nous exécuterons ces deux commandes
en même temps. Mais c'est très dangereux car imaginez que nous n'avions pas le dossier
dist ici et que nous exécutions la commande
node, node. Et dans ce cas,
indiquez que la commande sera interrompue, mais
que la commande de compilation sera exécutée. Et il surveillera les changements de signe
dans les fichiers TS. Mais lorsque la commande DOS
génère le dossier dist. Nous constaterons que
la commande node ne fonctionne pas et qu'elle ne
surveille pas les modifications, elle ne le saura
donc pas. Nous avons maintenant ce dossier
et dans ce cas, notre application va rester
bloquée lors de la phase de compilation. Oui. que je veux dire
ici, c'est que nous
ne pouvons pas utiliser la commande
Dash, Dash Watch ici. Et nous devons à
nouveau utiliser Node Man dans ce projet. Assurez-vous donc de réinstaller Node Man dans les dépendances de développement. Ensuite, utilisez-le ici avec la commande node sans
le mot fumé. Supprimons donc cela, puis prenons cette commande
et mettons-la ici. Supprimons ensuite ceci
et utilisons le nœud 1. Et avec le drapeau E puis le ts, alors ils cachent exactement. Ensuite, nous allons exécuter la commande, la commande de
compilation. Ici, npm, buy-in,
compile, enregistre ceci. Et essayons de
démarrer notre application. C'est vrai. Maintenant. Nous n'avons reçu aucune erreur
liée à une base de données, ce qui
signifie que nous avons réussi à établir une connexion à
la base de données Postgres. Maintenant, allons-y
et la poussière est sur le point de
terminaison GraphQL du sandbox
Apollo Nous avons ici une icône verte
qui signifie que nous nous sommes connectés avec succès
à notre point de terminaison GraphQL. Essayons maintenant d'inscrire un utilisateur avec les mêmes informations d'identification ici et de vérifier si nous pouvons
enregistrer des utilisateurs dans la base de données. Exécutons donc ces requêtes
d'inscription ici. Et si ce n'est pas le cas, si
ce n'est
pas le cas dans les vidéos précédentes, vous pouvez simplement revenir à la racine ici et cliquer sur mutation, puis choisir de vous inscrire. En fait, je vais générer à nouveau
la requête au cas où. Ajoutons donc la
requête d'inscription ou une mutation. Et les deux champs, l'utilisateur. Et ici, nous allons simplement
attendre l'identifiant pour assurer que nous avons
bien enregistré l'utilisateur dans la base de données. Maintenant, nous allons utiliser les
mêmes entrées ici. Et à partir de la mutation liée à l'inscription. Très bien, nous avons
ici le jeton JWT, et surtout, nous
avons défini l'identifiant sur un. Donc, si nous avons inscrit un nouvel utilisateur, nous devons l'obtenir. Nous devons nous faire une idée de deux. Remplaçons donc
l'e-mail ici en utilisateur 2 et en
FirstName user2, puis relançons l'inscription. Et attendons la réponse. Tu dois te procurer la deuxième pièce d'identité. Et il y irait. Maintenant, nous sommes sûrs que nous
enregistrons les utilisateurs dans la base de données et que nous obtenons également des résultats à partir de la base de données. Testons maintenant le
sélecteur coréen, qui peut être résolu ,
car la mutation sinus n a la même logique
que l'inscription. Oui, testons donc
l'utilisateur coréen. Et pour cela, nous devons envoyer
un en-tête d'autorisation. Copions donc le jeton JWT. Et ici, nous allons cliquer sur l'icône Paramètres et ajouter
les en-têtes d'autorisation. Donc, ici, lors de la théorisation, vous pouvez simplement commencer à rédiger une autorisation et vous
aurez quelques suggestions ici. Choisissez l'autorisation
et collez le jeton. Oui, cela permet de s'assurer que
le cookie est désactivé. Sinon, nous ne pouvons pas nous connecter
à notre point de terminaison GraphQL. Maintenant, sauvegardons ça. Et exécutons la requête utilisateur en
dégradé. Revenez donc à la racine ici. Supprimons tout cela
et cliquons sur la requête, puis ajoutons la requête utilisateur actuelle. Et attendons l'e-mail et
le nom d'utilisateur pour ne pas avoir besoin de la saisie. Nous allons donc simplement exécuter la requête utilisateur
actuelle. Et nous devrions obtenir l'
e-mail et l'identifiant. Nous y voilà. Nous avons réussi à faire en sorte que l'utilisateur le fasse, car nous utilisons le jeton JWT
lorsque nous nous sommes inscrits en tant qu'utilisateur2. Nous pouvons maintenant obtenir l'
e-mail et le nom d'utilisateur. Cela signifie que notre
contexte fonctionne et que nous pouvons extraire notre
charge utile du jeton. Maintenant, dans la vidéo suivante, nous allons créer une
image à partir de ce conteneur.
26. de conteneur postgres à image: Créons maintenant une image qui exécutera ce
conteneur pour nous. Sortons donc de
ce conteneur. Ensuite,
nettoyons le terminal. Et utilisons la commande docker
commit pour
créer une nouvelle image à partir du conteneur
postgres de
l'application, nommons cette base de données de
messages d'images
et exécutons commande docker
commit pour
créer une nouvelle image à partir du conteneur
postgres de l'application nommons cette base de données de
messages d'images cette commande. Et maintenant, essayons de
lancer cette image où Docker exécute plutôt que TI pour la direction
du terminal. Et puis j'ai mentionné
le nom de l'image. Et avant d'exécuter cette commande, nous devons
également exposer un port ici, car lorsque vous exécutez une
image à l'aide de Docker run, nous allons créer un
conteneur et le message,
notre image de base de données, va s'exécuter
à l'intérieur de ce conteneur. Nous allons donc exposer les mêmes ports que ceux que
nous avons exposés dans le conteneur Postgres de l'application en utilisant l'indicateur Desk P sur le port
5455, puis deux points, puis le port de la base de données
Postgres 5432. Maintenant, vous
n'avez probablement pas compris pourquoi nous utilisons les
mêmes ports ici. Et c'est parce que vous
pensez que lorsque nous exécutons l'image NSG add DB, nous allons réellement exécuter
le conteneur Postgres de l'application. Oui, mais ce n'est pas le cas car lorsque
nous exécuterons cette image, nous n'exécuterons pas le conteneur Postgres de
l'application, mais nous allons exécuter
l'image postgres avec toutes les variables d'environnement
et toutes les configurations. Le
conteneur Postgres de l'application n'a donc rien à voir avec l'image de la base de données MSG AB. Et maintenant, lorsque nous
exécuterons cette commande, nous allons obtenir un
conteneur qui exécutera également
l'image postgres avec toutes les variables d'environnement
et les configurations. J'espère donc que vous
comprenez maintenant pourquoi nous
devons à nouveau exposer les
mêmes ports. Maintenant, chaque fois que nous
exécutons cette commande, nous allons obtenir un conteneur
généré de manière aléatoire. Parce que lorsque nous
sortons d'un conteneur, celui-ci
n'est pas supprimé. Mais ce n'est pas ce que nous voulons. Nous voulons que chaque fois nous aurons fini d'utiliser un
contenant, ce contenant soit donné. Et nous pouvons le faire
automatiquement en ajoutant un nouvel indicateur à
la commande rand, qui est la commande RM. Et maintenant, nous pouvons exécuter cette commande. Et lorsque nous avons fini de travailler
avec le conteneur, cela signifie que lorsque nous le
quittons, le conteneur est supprimé
et nous n'aurons pas un tas de conteneurs générés de manière aléatoire dans notre référentiel Docker. Exécutons maintenant cette commande et attendons que connexion
à la base de données soit établie. Très bien, notre
base de données fonctionne. Revenons à notre
projet et au terminal. Exécutons npm. Courez, commencez. Assurez-vous que vous avez toujours
les 5455 balles ici. Exécutons la commande. Nous pouvons voir que nous n'avons
reçu aucune erreur de base de données. Maintenant, j'ai ici une double barre oblique
pour le point de terminaison GraphQL, et c'est parce que cela n'a pas changé ici
et n'indique pas le fichier main.js. Je vais donc le faire maintenant
et enregistrer le fichier main.js. Attendez le rechargement, puis vous devrez
obtenir la bonne année. Maintenant, accédez à cette URL. Et dans le
sandbox Apollo, vous trouverez l'API. Vous pouvez donc voir
ici que je testais la validation du référentiel
d'inscription. Donc, si nous nous sommes inscrits
avec le même e-mail, nous allons recevoir un mauvais message d'erreur indiquant que l'utilisateur existe
déjà. Nous savons donc que cette partie du
résolveur d'inscription fonctionne. Maintenant, inscrivons-nous comme d'habitude. Et ici, FirstName
user1 et lancez l'inscription. Et nous devrions avoir un utilisateur
avec un identifiant défini sur un. Hein ? Nous avons l'identifiant et le jeton JWT.
27. Définir la pièce Schéma: Il est maintenant temps de commencer à
travailler sur le room service. Et comme précédemment, nous
allons commencer par
le schéma qui représente le fichier DO. Mais je ne vais pas écrire
le schéma GraphQL du room service dans le graphe schématique
Gail Fail parce que c'est, vous savez, que c'est toujours
une bonne pratique de
diviser les fichiers en petits morceaux, surtout si vous
avez un gros fichier. C'est donc ce que nous
allons faire ici. Commençons par créer un nouveau dossier dans le dossier
source et nommez-le. Des booms. Et puis ici, nous
allons avoir les pièces ou
la pièce de GraphQL. Ensuite, nous
allons écrire notre schéma GraphQL
lié au room service. Ensuite, nous allons faire la même chose pour
les véhicules hors service. Et nous allons apprendre les fichiers DO bourru, fichiers DO bourru puis ajouter tout
cela automatiquement,
automatiquement dans le fichier TO du diagramme à points du
schéma. Alors voilà, commençons,
commençons par définir
le type de chambre. Créons donc un
type et nommons-le. Chambre. Et la ROM contiendra, bien sûr, un identifiant de type int et c'est obligatoire, ainsi qu'un tableau d'utilisateurs. Nous devons donc utiliser le type d'utilisateur. Et comme vous pouvez le voir ici, je n'ai pas d'erreur
car nous avons déjà utilisé le type d'utilisateur ou déclaré qu'il
s'agissait d'un type ici. Et comme je l'ai déjà dit, nous allons fusionner les deux fichiers,
le graphe de
la Terre
Gill et leur propre GraphQL dans le schéma,
ce fichier GraphQL. Nous aurons donc accès
au type d'utilisateur. Définissons donc ici
la pièce avec l'utilisateur et les messages. Ensuite, les messages,
ce sera un tableau d'objets de message. Et nous devons le
définir ci-dessus. Ici. Déclarez un autre type,
nommez-le message. Et son message aura
un champ de formulaire. Et c'est l'identifiant de l'utilisateur. Nous pouvons donc savoir qui a envoyé le message et le
contenu des messages. Et celui-ci est de type string. Maintenant, pour envoyer un message, nous avons besoin du message lui-même. Cela signifie le contenu. Et nous avons également besoin du bromure D pour enregistrer
ce message dans la pièce. Le message, le
message est un tableau. Tous les utilisateurs
du tableau de l'utilisateur auront alors accès
à ce message. Donc, si nous avons ici deux utilisateurs, l'
utilisateur a et
l'utilisateur B, le message de l'utilisateur a sera reçu à l'utilisateur B. Et bien sûr,
les deux utilisateurs auront accès
au même message. Créons donc une entrée ici,
saisissez-la et nommez-la,
envoyez un message. Et nous avons besoin du message
de type string, et nous avons besoin de l'
identifiant de chambre de type int. Créons maintenant la mutation qui acceptera cette entrée. Voici donc une mutation de type, la première mutation est la mutation
du message sable. Et ici, MSE
signifie Message. Et ici, nous
accepterons une contribution. Vous pouvez donner à cette variable le nom
que vous voulez. J'aime le nommer input. Donc, ici, cette entrée est de
type entrée de message envoyé. Et nous allons
rétablir la règle. Maintenant, sauvegardons ça. Bien sûr, nous n'avons pas terminé, mais je souhaite créer le fichier DO
orthographique ici. Oui, créons donc
un nouveau fichier dans le dossier et
nommons-le earth point GraphQL. Et ici, nous allons
copier tout cela dans le schéma GraphQL
et nous assurer de le couper. Ensuite, enregistrez ce fichier et revenez à l'autographe Gill et collez tout cela ici. Maintenant, nous ne devons pas
ajouter le schéma ici car cela endommagerait
notre point de terminaison GraphQL,
car nous allons le
définir automatiquement dans
le
fichier GraphQL à points du schéma. Supprimons-le donc. Et Safe
garantit également que la destruction échoue à l'intérieur de
tous les sous-graphes. Nous avons une mutation
et une requête et assurons qu'
elles sont toutes deux en majuscule. Il y a donc également une mutation dans le mauvais
GraphQL. Ensuite, nous allons créer
la requête et les nommer
de
la même manière que nous les nommer
de l'avons fait
dans Earth GraphQL. Et vous pouvez modifier
le nom ici. Oui, parce que ce n'est pas le cas, ce n'est pas une question de nom, mais c'est un
endroit qui porte le même nom. Vous pouvez donc avoir ça comme ça. Et dans ce cas,
vous devez changer la notation GraphQL de la pièce par
un m minuscule. Mais je ne le veux pas. Je veux un M majuscule, donc je vais le changer
comme avant, et c'est tout. la vidéo suivante, nous allons
écrire la logique qui gérera la fusion de ces deux fichiers automatiquement
la fusion de ces deux fichiers
dans le schéma
GraphQL.
28. Générer et fusionner des schémas automatiques: Maintenant, créons le fichier
dans le dossier source et nommons-le,
générons le schéma. Du côté T, nous allons écrire la logique
qui fusionnera tous les sous-graphes de vos schémas dans le fichier GraphQL à
points de schéma. La première chose à
faire est donc d'importer tous les fichiers qui se terminent par un point GraphQL à partir
du dossier source. Et pour cela, nous devons
installer un nouveau package. Ouvrez donc votre terminal
et exécutez la commande npm, installez le package globe et installez également les
types de ce package. Et lancez cette commande. Très bien, maintenant fermons le
terminal et revenons ici. Et commençons par importer
le package du globe. Alors voilà, un globe lumineux. Globe est donc en fait une
fonction que nous pouvons appeler et spécifier le chemin des fichiers que nous
voulons rechercher. Donc, pour nous, nous allons
effectuer une recherche dans le dossier source et
dans n'importe quel dossier, puis dans n'importe quel fichier
se terminant par GraphQL. Ensuite, nous devons définir un rappel qui
acceptera une erreur et des fichiers. Donc, si nous avons une erreur, nous allons générer une erreur, générer une nouvelle erreur, ou
simplement lancer le, continuons. Tout d'abord, nous devons supprimer le fichier GraphQL à
points de schéma existant en utilisant la méthode
de dissociation du FS Beckett. Donc, à partir des paquets du système de fichiers. C'est donc important. Le lien ne provient pas seulement de nous, mais aussi des promesses des
pharmaciens. Et nous devons attendre un lien, puis supprimer
le point de schéma GraphQL. Très bien, déclarons maintenant une variable et nommons son
tableau de types. Force
sera de type array et contiendra des chaînes. Il va donc conserver tous
les schémas sous forme de chaînes. Et cela est initié
à un tableau vide. Et puis ici,
lisons tous les fichiers et insérons-les sous forme de chaînes
dans le tableau des types. Pour cela, nous devons parcourir les fichiers
en utilisant la méthode for each. Ici, prenez chaque
fichier et extrayez le schéma du fichier en utilisant une autre méthode du package
du système de fichiers, savoir la synchronisation des fichiers de lecture. Nous allons donc
lire en fait un fichier. Et ici, passons
le dossier ici. Ce fichier est donc un chemin ou simplement le nom du fichier, voici
le chemin du fichier. Et cela revient en fait à
le changer en chemin de fichier ici. Chemin du fichier, ici, chemin du fichier. Et ici, nous devons définir
l'encodage car nous devons extraire le
schéma sous forme de chaîne. Encodons donc en UTF huit, puis prenons le schéma et insérons le
dans le tableau des types. Tapez donc un tableau, poussez le schéma. Maintenant que nous avons fait cela, nous devons créer une autre variable et la nommer
« décès ». Et ici, nous devons fusionner
tous les brouillons de vos schémas. Donc, toutes les chaînes du tableau des
types dans un seul fichier. Et pour cela, nous avons besoin l'outil de fusion à partir des paquets d'outils
GraphQL. Passons donc à
notre terminal et adaptons
le GraphQL à Beggars NPM. Donc, chez GraphQL, Dash Tools puis Slush Merge. Très bien, fermons le
terminal et revenons ici. Et importons d'abord l'outil de fusion à partir de
la spécification inférieure. Importez, importez donc des développeurs
de type nourish depuis GraphQL. Alors des outils plutôt que des produits dérivés. Et nous allons
utiliser cette méthode. Copions donc le nom
ici et collons-le ici, puis citons-le. Nous allons réussir
l'enquête type. Maintenant, cette méthode va
générer une note de document, mais pour ajouter
quelque chose à un fichier, nous devons générer une chaîne. Pour cela, nous avons besoin d'
un autre outil de GraphQL. Importez donc depuis GraphQL
une autre méthode appelée print. Le front va donc prendre le typedef supérieur et le
convertir en chaîne. Donc disons ici, cela place cela
dans les méthodes de l'usine. Maintenant, le type, c'
est du type chaîne. Ajoutons donc
la chaîne dans
le fichier
GraphQL à points de schéma en utilisant la méthode
d'ajout depuis le bagage FS. Assurez-vous donc de les importer ici. Et maintenant, utilisons-le et mentionnons le
schéma GraphQL. Et ici, nous
devons ajouter les types que nous pouvons ajouter au fichier
graphique schématique Gil. Et cette fonction
accepte également un rappel. Définissons donc la fonction
et nous accepterons une erreur. Ensuite, si nous avons des erreurs, nous allons mieux les
lancer. Bien, maintenant, si nous avons terminé, je veux voir un message de confirmation
sur mon site, mon terminal. Je vais donc enregistrer sur la console message
généré par
le schéma GraphQL. Ou peut-être utilisons-nous
les informations point de la console. Et avant
d'ajouter
ce fichier GraphQL au schéma, nous devons créer ce fichier
car nous y sommes. Nous allons supprimer
le kill de schema.gov. Pour créer un fichier,
nous devons donc utiliser la
bonne méthode de synchronisation de fichiers à partir des paquets FS. Et encore une fois,
assurez-vous
de l'importer depuis le package FSLR. Ici, nous allons également ajouter
le schéma GraphQL. Il s'agit donc d'un chemin vers
la culpabilité du graphe schématique. Et en
ne mentionnant que le nom, nous transformons cette méthode pour
que le graphe
schématique Gill existe réellement à
la racine de ce projet. Voici donc un schéma graphique. Et je veux
ajouter à ce fichier un message disant qu'il s'
agit d'un schéma généré. Alors là, disons de ne pas le faire. Hein ? Maintenant, ajoutons
également une nouvelle ligne. Et ici, nous devons ajouter un drapeau à un objet et à
l'intérieur de cette option de type div. Et comme nous allons
ajouter quelque chose à ce fichier, nous allons utiliser l'indicateur
a pour ajouter. Et comme nous
supprimons le schéma
GF q five ici, nous devons utiliser le signe plus pour créer le fichier
s'il n'existe pas. Maintenant, permettez-moi d'ajuster le code ici. Et ajoutons également
une autre ligne ici. Barre oblique inverse pour une nouvelle ligne. Nous avons maintenant terminé de créer ce script et nous
allons exécuter la fonction globe en
tant que commande à partir du fichier
package.json. Nous devons le faire avant de
générer de force les types
pour notre schéma GraphQL. Donc, avant cette commande, nous allons exécuter
note, puis nous référer
au dossier dist et à la source pour
générer le schéma Z, S. Et ici, dans la commande de compilation, nous allons compiler notre code, puis nous allons
exécuter la commande degenerate. Alors ici, npm, run generate
two et science aussi ici. Et puis enregistrez. Maintenant, ouvrons le terminal
et exécutons Degenerate come out. Et bien sûr, nous devons d'abord
compiler le code. Alors lançons TSE. Ensuite, exécutons
le npm run generate. Et voilà, nous avons le message
généré par le schéma GraphQL. Et maintenant, nous devons analyser le diagramme
girl et y ajouter tous ces types
TypeScript générés. Voyons maintenant le
schéma de cet équipement de golf. Et nous y voilà. Nous avons notre schéma généré. Nous avons nos types et nos contributions. Et voici la mutation, vous pouvez voir que nous
avons les mutations désactivées, l'inscription et la connexion. Et nous avons la mutation, la mutation d'envoi du message, ajoutée
automatiquement
dans le type de mutation. Et bien sûr, nous n'
avons qu'une seule requête, la requête utilisateur actuelle. Et vous pouvez également voir ici
que le schéma est également
généré automatiquement ici. Oui. Et souvenez-vous quand j'ai dit que nous allions avoir
accès à l'utilisateur ici, si vous ne l'avez pas compris. Je veux dire que lorsque nous générons
le schéma, le schéma, le GraphQL, nous allons
avoir tous les types dans un seul fichier. Nous allons donc
également avoir accès au type d'utilisateur. Oui. Vous pouvez donc utiliser les types d'utilisateurs contenus dans le fichier GraphQL à points de
chambre, même si nous ne l'
avons pas déclaré ici. Maintenant, dans la vidéo suivante, nous allons créer
les résolveurs de chambre. Et puis dans le
module, le fichier ts, nous allons le
fusionner avec les résolveurs.
29. créer le résolveur de pièce: Maintenant, dans le dossier rooms, créons un nouveau
fichier et nommons-le à partir du côté point ds du résolveur Exportons une constante avec
un nom, Room Resolvers. Et cette constante sera
un objet type. Le résultat semble. Il est important que, à partir de
nos types générés. Donc, un port se
résolve de sortir Lorsque vous êtes au niveau et sélectionnez ces dossiers
intégrés , puis sélectionnez les résolveurs. Les fichiers de types Dash sont
maintenant à l'intérieur. Nous allons
définir la mutation. Et nous n'avons qu'une seule mutation, qui est la mutation d'envoi du
message. Maintenant que nous n'avons pas
créé l'entité, nous allons renvoyer
des données créées manuellement. Ici, définissons d'abord
la station de messagerie Sand. Et nous avons le parent, la contribution et le contexte. Ça va ? Désormais, seuls
les utilisateurs autorisés peuvent définir un message. Vérifions donc si nous avons un utilisateur autorisé en
vérifiant les contextes qui ont
autorisé la propriété. Ensuite, si nous avons de la force, nous allons générer
une nouvelle erreur GraphQL et nous assurer de l'importer
depuis GraphQL. Et puis je vais renvoyer méthode
non autorisée
ou un message. Donc, un message autorisé, et c'est une extension. Voici donc les tensions. Et nous allons envoyer le manteau
non autorisé ici. Et pour les personnes âgées. Et maintenant,
renvoyons un objet de chambre. Laissez-moi donc vérifier à quoi ressemble
l'objet. Nous avons donc un identifiant,
les messages des utilisateurs. Ajoutons donc cela. Tout ce retour n'en fait qu'un. Et pour les utilisateurs, nous devons créer un
tableau d'objets utilisateurs, mais nous pouvons simplement
renvoyer un tableau vide et également le tableau des messages. Mais c'est un sac de sable, juste un message. Laissez-moi vérifier à quoi ressemble le
message. Nous avons des
champs de formulaire et de contenu provenant et un objet provenant,
disons, d'un et du message de test de
contenu. Très bien, maintenant, enregistrons
ce fichier de résolution. Ou en fait,
utilisons l'entrée l'objet du message juste pour assurer que nous pouvons
être les données du client. Pour le contenu,
je vais renvoyer
le message à points d'entrée. Et voici le message, qu' agisse d'une chaîne ou non défini car nous n'avons pas ajouté de point d'
exclamation ici. Alors allons-y. Enregistrer. Bien entendu, nous devons à nouveau
générer le schéma. Alors lançons NPM, générons npm, sommes entrés, non ? Très bien, nous avons maintenant généré
le schéma et les types. Revenons donc aux
serveurs normaux et nous pouvons voir que
l'erreur a disparu. Nous pouvons supprimer le point d'
interrogation à partir d'ici. Et le message est désormais
uniquement de type chaîne. Et ici, à l'intérieur de l'identifiant, nous allons renvoyer
l'identifiant de la chambre. Parce que c'est une pièce bouleversée. Oui, sauvegardons ça. Et dans la vidéo suivante,
nous allons fusionner. L'auteur est terminé et
la salle se résout
ici dans le fichier
module.js, puis teste le point de terminaison GraphQL.
30. fusionner des résolveurs: Maintenant, pour
fusionner les résolveurs, nous avons besoin d'un autre outil
du GraphQL pour supprimer les paquets de
fusion. Donc, en haut de ce fichier, importons le nouvel outil,
alimentons les résolveurs de GraphQL, les outils de tableau de bord qui dégagent une odeur de package. Et nous devons également
importer le résolveur de chambre. Voici donc les résolveurs de règles provenant du dossier rooms et
du fichier Room Resolvers. Très bien, maintenant, en
bas,
nous allons utiliser
la
fonction ou l'outil de résolution de fusion dans
la classe du module d'application. Permettez-moi donc de couper cela, puis d'utiliser les résolveurs de fusion
comme fonction. Et cette fonction accepte
un tableau de résultats. Je vais donc ajouter un tableau
, puis coller le bureau des
auteurs ici. Et vous pouvez constater que l'
erreur a disparu car les résolveurs marchands
renverront le type de résolveur. Et ici, nous pouvons
ajouter
autant de résolveurs que nous le souhaitons, car
nous acceptons un tableau. Ajoutons donc également les
résolveurs de salle et enregistrons ce fichier. Maintenant, vérifions si
nous pouvons toujours exécuter notre PI et si nous
n'avons rien cassé. Ouvrons donc le terminal et
exécutons la commande npm start. D'abord. Assurons-nous d'avoir une base de données active. Donc, utiliser Docker, en est une. Ensuite, ce tiret ou M pour retirer le conteneur une fois que
nous avons fini de travailler avec lui, puis TI pour le terminal
et la direction, puis nommez notre message DB Image. Et n'oubliez pas d'exposer
le port 5455 et le 5432. Et exécutons cette commande. C'est vrai. Maintenant. Revenons ici
et exécutons npm start. Cette commande
va d'abord générer le schéma,
puis générer les types, puis un, l'API. Mais d'abord, nous
allons compiler le code, puis exécuter
la commande incinerate, puis exécuter notre API. Nous avons ici le
schéma GraphQL généré. Nous avons également les types. Et maintenant, nous devrions recevoir
le message de réussite. Maintenant, ouvrons le bac à sable. Sandbox et inscrivons-nous d'abord. Donc, voici la mutation
d'inscription, j'ai toutes les entrées. Essayons de nous inscrire. Comme vous pouvez le voir ici,
nous avons l'identifiant. Et c'est parce que chaque
fois que nous fermons la base de données et que nous la
réexécutons, nous obtenons une nouvelle base de données. Oui. Prenons maintenant le
jeton JWT , accédons
aux paramètres et ajoutons-y l'en-tête
d'autorisation. Ici, l'autorisation ou
le jeton JWT, enregistrez. Et maintenant, exécutons la mutation du message
envoyé. Permettez-moi de clarifier tout cela. Et revenons
à la mutation. Et un message de sable, ou la prédation d'
un message d'envoi. Les résultats sont les champs. Ici. Nous n'avons pas d'utilisateurs, mais nous allons y ajouter l'identifiant. Et nous allons obtenir la forme, le message
et le contenu. maintenant à la saisie Effacons d'
abord tout cela , puis ajoutons le
message et l'identifiant de la salle. Donc, le message ici,
c'est le message. Et l'identifiant de la chambre.
Disons, bien sûr, que nous n'avons pas
de table d'
identification des chambres, définissez la base de données. Alors, envoyons un message. Et nous devrions rentrer. Et l'objet de l'identifiant de la salle avec
id1 utilise un tableau vide. Et nous avons ici
notre message avec le message de test du
message directement ici. Maintenant, tout fonctionne. Nous devons encore créer l'entité de pièce et terminer
les résolveurs de pièce.
31. créer l'entité de la pièce: Créons maintenant
l'entité de pièce. Donc, dans le dossier des salles, créez un autre dossier
et nommez-le rule. Ensuite, créez un autre dossier
et nommez-le entité. Et enfin, créons
l' entité Room Dot, oui. Commençons donc par Exporter et définissons
une classe nommée Rome. Ensuite, nous devons utiliser l'entité, le caractère de la bande magnétique, l'entité de
support de type ou N, et l'utiliser pour cette classe. Maintenant, à l'intérieur, nous
allons commencer par l'identifiant. Et encore une fois, nous devons importer la colonne générée principale, le caractère de l'identifiant. Et ici,
il est étrange
que le personnage besoin d'un éventail d'utilisateurs. Nous allons donc ajouter des utilisateurs et les définir comme un tableau d'utilisateurs. Et nous devons importer l'entité
utilisateur depuis l'utilisateur, cette entité point ds. Donc, ici, l'utilisateur
remonte d'un niveau, deux niveaux et de trois niveaux. Côté Le dossier utilisateur désactivé et
triste. Sélectionnez l'intérieur
du dossier de l'entité. Sélectionnez l'utilisateur,
ce fichier d'entité. Maintenant, les utilisateurs sont
une colonne, nous devons
donc importer
une couleur et le caractère à partir du type around. Alors voici Carlin, et utilisez-le ici. Maintenant, pour la colonne utilisateurs, nous allons créer une relation de plusieurs à plusieurs
avec l'entité utilisateur. Et pour cela, nous devons
importer le « plusieurs », le personnage à partir de
cassettes, et l'utiliser ici à de très nombreuses reprises. Nous devons maintenant définir le
type de relation, et dans notre cas, il s'agit de l'entité utilisateur. Nous devons donc ici
ajouter une fonction et rechercher ou renvoyer l'entité
utilisateur en tant que type. Maintenant, pour que cela fonctionne, nous devons ajouter
un autre personnage, la table de jointure à
Garreta, et l'utiliser ici. Donc, la table de jointure, le personnage va prendre les identifiants de la pièce et des entités utilisateurs et les
enregistrer dans une seule table. Il ne nous reste plus qu'à utiliser la relation de plusieurs à plusieurs d'
un côté de la relation. C'est ce qu'on appelle une relation
unidirectionnelle. Si vous souhaitez créer une relation
bidirectionnelle, vous pouvez accéder à l'entité utilisateur. Et à l'intérieur, vous pouvez
créer une autre colonne , la nommer règle, et utiliser
le nombre de caractères. Nous avons maintenant l'entité
de la pièce. Et cela devrait être un tableau. Et utilisez le caractère « plusieurs
à plusieurs ici et définissez le type. Nous allons donc
obtenir l'entité de la pièce. Et ici aussi, nous devons
ajouter une autre fonction dans laquelle nous devons renvoyer la propriété qui possède l'
autre côté de la relation. Donc, dans notre cas, mis à part l'objet de la pièce, nous allons obtenir
l'autre côté de la relation à partir de
la propriété de l'utilisateur. Et nous devrions faire la même
chose à l'intérieur de l'entité de la pièce. Mais pour la
table de jointure, le caractère, nous ne devons l'utiliser que dans un seul
côté de la relation ici. Alors ici, faisons la même
chose, juste un exemple. Voici donc l'utilisateur,
puis return, l'utilisateur
a renvoyé la chambre point, car la propriété room possède l'autre côté
de la relation. Et ça devrait être des
chambres, pas de la place ici. Mais encore une fois, ce n'est qu'un exemple. Oui, nous n'allons pas utiliser la
relation bidirectionnelle ici. Nous n'aurons besoin que d'une relation syndicale, de relations
unidirectionnelles. Étudions donc cela et sauvegardons-le, revenons à l'entité utilisateur
et supprimons tout cela. Et assurez-vous de supprimer toutes les instructions d'entrée de l'entité de
règle et de la fermer. Maintenant, nous n'avons toujours pas
terminé car la base de données Postgres
ne prend pas en charge les tableaux. Ouaip. Et pour cela, nous devons utiliser un type de JSON tout à fait
unique, qui est le JSON B. Maintenant, les types de données
Jason et Jason B sont presque identiques. La principale différence
réside dans le fait que les données JSON
sont stockées sous la forme d'une copie exacte
du texte d'entrée JSON. Qu'est-ce que JSONB stocke les
données dans un décomposeur. Binaire pour cela, ce
n'est pas une chaîne. Oui, comme JSON, mais
en tant que code binaire. Et c'est ce que signifie le
binaire. Notre ADB signifie, il représente un binaire. Maintenant, c'est la
seule façon de travailler avec des tableaux avec Postgres. Nous devons donc le faire. Vous devez utiliser JSON v
plutôt que de simples tableaux qui ne
sont que du JSON simple. Maintenant, je vais ajouter une
option ici et dire nullable, false parce que je
ne veux pas obtenir valeur nulle ici pour
la propriété des utilisateurs. Très bien. Maintenant, nous avons toujours
besoin des messages. Ajoutons-le donc ici. Et ce
sera du type message. Et nous pouvons l'importer à
partir des types générés. Assurez-vous de le modifier. Sortez de deux niveaux, pensez à trois niveaux. Et voilà, nous allons
en faire un tableau. Si vous passez la souris sur ce type, vous constaterez que
nous avons le contenu et le formulaire en tant que propriétés
requises. Et nous avons ici le nom du type, qui n'est pas obligatoire. Par conséquent, nous pouvons utiliser
le type de message ici. Oui, ce n'est pas le problème. Maintenant. Ici, définissons une colonne. Une colonne. Et nous devons utiliser le début adjacent car
nous ne pouvons pas utiliser l'effacement simple. Et je veux qu'il ne
soit pas nul. Je vais donc ajouter
nullable égal à faux. Et en sécurité.
32. créer et mettre à jour des salles: Maintenant, dans le dossier room, créons un autre
fichier et
nommez-le room point service, oui. Exportons ici un service
de salle de classe et créons ainsi le constructeur. Et ici, nous allons créer
la pièce, notre référentiel. Et ce sera
du type référentiel. Nous pouvons l'importer
depuis du ruban adhésif. Importez donc le référentiel
depuis type around. Ici, nous devons ajouter
l'entité de chambre
comme argument ici, Rome. Et c'est important de
la part de l'entité. Définissons maintenant la méthode qui créera une pièce pour nous. Alors ici, en jouant, créez de la place. Et cette méthode acceptera
un argument de participants, qui est un ensemble d'utilisateurs. Voici donc l'utilisateur du tableau, et voici l'entité utilisateur. Nous devons donc l'importer
à partir d'ici, transférer l'utilisateur depuis deux niveaux, puis
sélectionner le dossier Oath. À partir de là, le dossier utilisateur, l'entité et le fichier de
l'entité utilisateur, pas seulement les participants ici présents, nous avons également besoin du message. Parce que lorsque nous
allons créer une salle, lorsque l'utilisateur essaie d'
envoyer un message à un autre
utilisateur pour la première fois. Donc, ici, le message
va être de type message. Et encore une fois, nous allons importer
cela à partir de ces types générés. Donc, ici, importez le message de
l'extérieur vers un niveau, deux niveaux. Et puis dossier
généré le samedi, sélectionnez le fichier des types de résolveurs. Nous allons maintenant
créer une salle avec le référentiel et dans
laquelle ils créent des méthodes. Maintenant c'est vrai, sauf pour les utilisateurs. Donc, les utilisateurs ou
les participants, et accepte également
le tableau de messages. Donc, comme nous allons
créer une nouvelle pièce, nous allons ajouter le message
manuellement dans un tableau. Nous allons donc obtenir un
tableau avec un seul message. Très bien, maintenant nous devons
retourner un poids, ce référentiel de pièces à points qui enregistre et transmet le document de chambre. Maintenant, il semble qu'
ils aient une faute de frappe ici dans le référentiel. Alors laisse-moi régler ça. Et je vais utiliser la sélection multiple et le remplacer par peut-être un référentiel, n'est-ce pas ? Maintenant, économisons. Et maintenant, nous devons gérer
le cas
où nous voulons envoyer un
message à une règle spécifique. Nous allons donc créer
une autre méthode. Il va redevenir asynchrone et choisir le nom, ajouter des messages à lancer. Vous pouvez choisir le nom du
message et du message. Mais je tiens à être très clair fait que nous allons
envoyer un message à une pièce, et ici nous allons
créer une salle. Oui. Maintenant, pour envoyer un message
à une pièce spécifique, nous avons besoin de l'identifiant de la salle, bien
sûr, du numéro de type. Et nous avons besoin du type
de message, du message. Voilà, message. Et maintenant, c'est ici. Nous allons utiliser
le Query Builder. Et c'est parce que nous devons faire
face à Jason par des réseaux. Donc, si vous vous en souvenez, nous définissons la
colonne des messages comme JSON B. Et comme nous avons ici,
le signe de tableau de TypeScript sera
de type Jason be array. La seule façon de
traiter les tableaux Jason
be est donc d'utiliser
la requête construite. Définissons maintenant le générateur de
requêtes ici. Ce point est
certainement notre propre référentiel. Créez un générateur de requêtes. Et ici, créons
un générateur de requêtes de pondération. Mise à jour. C'est fait, nous allons mettre à jour une salle existante
, puis ajouter le nouveau message
dans le tableau des messages. Donc, mettez à jour, nous avons besoin de l'entité de la
pièce ici en tant que type et de la propriété qui
sera mise à jour dans un objet. Nous allons donc mettre à jour
les messages et utiliser méthode
très spécifique et unique
pour mettre à jour cette propriété. Nous allons donc
utiliser une méthode ou une fonction pour renvoyer une requête. Dans cette requête, vous aurez le nom de la propriété des messages,
puis ajouterez 2 barres ici. Et je vais expliquer
cela dans une seconde. Oui. Et maintenant, ajoutons des
guillemets. Et à l'intérieur, nous allons
ajouter les messages
sous forme de chaîne JSON. Nous allons donc utiliser la méthode
JSON stringify et transmettre le message. Et puis souvenez-vous que nous devons ajouter des messages
au fur et à mesure que Jason battait. Nous allons donc le
convertir en Jason V en ajoutant deux colonnes. Et puis, d'accord,
Jason, sois comme ça. Toute cette chaîne
est donc une requête Postgres. Et lorsque nous ajoutons les deux
colonnes, le Jason sera analysé
par Postgres sous forme de requête. Et Postgres s'occupera de la
conversion de cette chaîne, de cette chaîne JSON, de
deux battements adjacents. Et les 2 barres ici signifient
que nous allons
ajouter cette chaîne JSON B et
à la propriété messages. Maintenant, en utilisant le
générateur de requêtes pour ajouter une requête avec
la méthode de mise à jour, nous devons la renvoyer
sous forme de méthode. Bien, maintenant, permettez-moi d'ajuster ce code et de continuer
avec le Query Builder. Nous allons donc mettre à jour une pièce, mais nous devons identifier la pièce que nous
allons mettre à jour. Et pour cela, nous
utiliserons la méthode Where. Et cette méthode va ajouter une condition où dans le générateur de requêtes et
créer la condition where. Nous allons ajouter une chaîne ici
et dire que nous allons
mettre à jour une pièce où l'
ID est égal à l'ID de la variable, et nous pouvons définir cette variable dans un autre
argument de cette méthode. Et à l'intérieur d'un objet, définissez l'identifiant, et il sera
défini sur l'identifiant de la pièce. Maintenant, nous devons toujours exécuter cette requête en utilisant
la méthode execute. Et si vous passez la souris dessus, vous constaterez que cette
méthode va renvoyer les résultats d'une base de données de lignes, mais que nous devons
renvoyer un type de pièce. Et donc,
cette méthode d'exécution de
requêtes ne fonctionnera pas avec
un environnement TypeScript. Par conséquent, je vais
renvoyer un poids et
rechercher le document mis à jour. Il y a donc le référentiel de salles ,
puis utilisez la méthode
find one. Et je vais
rechercher une pièce avec ou où l'identifiant est égal
à l'identifiant de la chambre. De plus, pour
renvoyer les relations, nous devons ajouter la propriété des
relations et spécifier un tableau ou un tableau des relations que
nous voulons récupérer. Dans notre cas, nous n'
avons qu'une seule relation, qui est le tableau de l'utilisateur. Et c'est tout. C'est ainsi que nous pouvons mettre à jour
une entité et la renvoyer
avec le Query Builder.
33. Résolveur de CreateRoom 1/2: Maintenant, avant de commencer à
utiliser le service de chambre, nous devons importer
la source
de données de l'application créer une instance ici et transmettre le référentiel de
chambre. Importons donc d'abord la source
de données de l'application à partir de deux niveaux, puis
sélectionnons la source de données. Maintenant, nous devons exporter une constante, la nommer
room service, et créer une nouvelle instance
de room service. Transmettez ou utilisez la source de
données de l'application, puis pointez le référentiel
Git et
transmettez l'entité room. Et ici, changez cela pour exporter. Très bien, sauvegardons
ceci et fermons-le. Revenez en arrière ou ouvrez les salles
des résolveurs et importez le service
de chambre depuis le fichier de service de chambre. Et ici, définissons le message
ou envoyons le résolveur de messages. Supprimons la déclaration de
retour. Et nous allons
reprendre le poids. Les chambres envoient
ce message à Rome et transmettent d'
abord l'identifiant de la chambre en saisissant mon identifiant. Ensuite, nous devons
transmettre le message. Et le message est un objet
avec un contenu de propriété. Et nous allons
obtenir le contenu
en saisissant ce message. Nous devons également
ajouter la propriété from, qui est l'identifiant de l'expéditeur, qui dans notre cas est
l'identifiant utilisateur actuel. Et nous pouvons l'obtenir
à partir du contexte, cet utilisateur coréen, de ce nom d'utilisateur. Maintenant, nous avons terminé avec le résolveur de messages
Sand. Maintenant, ajoutons
une virgule, puis créons le résolveur Create Room. Donc Async, créez de la place, puis pour le parent. Donc, ici, créez une pièce et
je serais parent, puis ajouterais l'entrée et le
contexte, le contexte. Hein ? Nous
avons donc créé de la place, mais nous obtenons ces erreurs
parce que nous n'avons pas défini le créateur de la mutation dans le schéma GraphQL de
notre chambre. Alors faisons-le très rapidement. Ici. Créons une autre
mutation et nommons-la. Créez une pièce. Et saisie du type. Créez une pièce, saisissez. Et définissons cela ici. Entrée, création d'une entrée de pièce. J'ai donc ici la saisie semi-automatique. Très embêtant. Réglons ça. Et au lieu de cela, ils
créent de la place dans le livre. Nous allons accepter
un champ de message avec une chaîne de caractères et un récepteur. Les gars de type int vont
obtenir l'identifiant du récepteur. Nous devons maintenant
renvoyer le type de retour. Je vais donc renvoyer
la ligne, puis enregistrer. Retournez au résolveur de la pièce. Et pour cela, nous devons générer le schéma ou les types
à partir du schéma GraphQL. Ouvrez donc votre terminal et
exécutez npm, exécutez generate. Pour l'instant, je pense que
nous avons oublié d'ajouter. qui est très important, c'est notre schéma ici, qui consiste à rendre obligatoire la saisie de création d'
une pièce. Sinon, vous obtiendrez des erreurs
TypeScript lorsque essaierez d'utiliser
l'entrée use the create ROM. Alors,
réexécutons cette commande et effaçons cette commande ou supprimons
simplement le terminal. Retournez ici. Maintenant, la première chose à faire est d'
authentifier l'utilisateur. Je vais donc copier tout
cela et le coller ici. Maintenant, nous devons vérifier
si nous avons déjà une pièce contenant le
destinataire et l'expéditeur. Et pour cela, nous devons créer une autre méthode
au sein du room service. Ouvrons donc le room
service et
créons une autre
fonction asynchrone et nommez-la, find, boom, avec un identifiant utilisateur. Très bien, nous allons maintenant obtenir ou rechercher un utilisateur pour une
chambre avec l'identifiant du destinataire, le numéro de
type et l'
identifiant de l'expéditeur du numéro de type également. Et ici, nous allons utiliser le Query Builder afin de
récupérer les relations des utilisateurs. Créons donc une constante ici et nommons-la Query Builder. Ensuite, utilisez le référentiel de salles pour créer une nouvelle requête avec eux. Ajoutons
ici un alias pour faire référence à l'entité room de la
table de salle dans une base de données et créons une constante Rooms,
car nous allons récupérer toutes les salles contenant un utilisateur avec l'identifiant et l'identifiant de l'expéditeur
. Alors allons-y. Générateur de requêtes Await. Ensuite, sur une autre ligne, sélectionnons tout,
puis utilisons la méthode de jointure interne pour joindre toutes les relations au sein de la propriété room point
users. Trouvons donc ici
les utilisateurs, puis nous allons ajouter un,
un alias pour faire référence à
la relation entre les utilisateurs. Et je vais
simplement choisir la lettre U ici. Ensuite, nous allons ajouter une condition
où
satisfait la condition. Nous allons cartographier
le tableau des relations de l'utilisateur. Et c'est en ajoutant des
guillemets doubles comme celui-ci. Vous êtes doré, puis ajoutez un autre
guillemet double avec un point ici pour sélectionner l'identifiant. Ensuite, vérifiez si l'identifiant est égal à l'identifiant de l'expéditeur
variable. Et ici, nous pouvons définir
cet identifiant d'expéditeur variable. Ensuite, nous allons
utiliser les méthodes « get
many » pour obtenir de nombreuses chambres. Ensuite, nous allons utiliser JavaScript
pour renvoyer un booléen ici, renvoyer puis ajouter des points d'
exclamation doubles ici. Ensuite, les chambres se trouvent à un point d'interrogation
parce que nous pouvons obtenir zéro. Ensuite, la somme est la méthode de somme
qui
permet de vérifier si certaines chambres présentent une condition très spécifique, à savoir arrondir le nombre d'utilisateurs. Nous allons donc vérifier
si c'est l'une des chambres. Et dans la propriété de ces utilisateurs, nous pouvons trouver au moins un utilisateur dont l'AD est
égal au récepteur AD. Bon, maintenant nous avons
quelques méthodes, mais c'est un gay. Et maintenant, nous pouvons empêcher la création de plusieurs salles
pour les mêmes utilisateurs.
34. CreateRoom résolveur 2/2: Maintenant, si nous avons une salle qui compte deux utilisateurs avec l'identifiant du
récepteur et l'identifiant du centre, nous n'allons pas créer de nouvelle
salle pour eux. Créons donc une constante
ici et nommons-la. La chambre a des utilisateurs. Utilisez ensuite le service de chambre qui trouve une chambre avec un identifiant
utilisateur ou un identifiant d'utilisateur. Ensuite, nous devons transmettre
l'identifiant du destinataire à partir de l'entrée de ce récepteur et l'identifiant de l'expéditeur à partir des contextes cet utilisateur coréen, de cet identifiant utilisateur. Très bien, maintenant vérifions. Si nous avons une salle
qui compte des utilisateurs, nous allons ajouter YouGov KL et dire que récepteur existe déjà ou
que la chambre existe déjà. Oui. Donc, cette chambre existe déjà. Et c'est tout. Maintenant, si nous n'avons pas trouvé de pièce où se trouvent le
destinataire et l'expéditeur, nous allons envoyer ou créer la salle, puis
envoyer le message. Revenons donc à 08, le room service
qui a créé la ligne. Cette méthode accepte désormais le tableau
d'un participant, qui est un tableau utilisateur. Nous devons donc récupérer les utilisateurs
depuis le référentiel des utilisateurs. Et pour cela, nous
allons créer une autre méthode au sein du service
utilisateur qui renverra plusieurs
utilisateurs par leurs identifiants. Créons donc une méthode asynchrone
et nommons-la find par ID. Parce que nous allons passer à un, transmettre un éventail d'idées, en nommant There's
find by ID in array. Et voici des idées, des
arguments de type,
un tableau de nombres. Et revenez. Attendez que le référentiel
utilisateur ne trouve pas par identifiant existant
dans le tableau des identifiants. Et pour cela, nous allons utiliser une méthode
à partir d' type de RAM appelée méthode. Assurez-vous donc de l'importer d'
abord à partir de type ramp, puis du tableau de l'identifiant. Et la méthode trouvera tous les utilisateurs dont les identifiants
existent dans le tableau. Nous pouvons donc nommer cette
méthode find by IDs plutôt que find
by ID in array. Très bien, maintenant,
enregistrons le service utilisateur, fermons-le et revenons ici. Et nous allons créer
un sondage pour les participants. Participants. Et je vais utiliser
le service utilisateur. Tout d'abord, il est importé depuis le dossier off et depuis
le fichier du service utilisateur. Et puis voilà, attendez le
service utilisateur qui le trouve par identifiant. Et nous allons transmettre un tableau avec deux identifiants provenant des
contextes que CurrentUser. Je vais récupérer le nom d'utilisateur. Depuis l'entrée. Nous allons
obtenir l'identifiant du récepteur. Oui, alors, passons les participants
et le message. Le message a donc
deux propriétés. Le premier est le contenu. Vous pouvez l'obtenir en
saisissant ce message et en utilisant la propriété from qui représente le récepteur
ou l'ID de la baie centrale. Et nous pouvons l'obtenir à partir de l'identifiant
utilisateur CurrentUser point. Et c'est tout pour le résolveur
Create Room.
35. Créer un résolveur getRooms: Nous allons maintenant
créer une requête qui
récupérera toutes les pièces
de la base de données. Nous allons donc
partir de la pièce où se trouve le schéma
GraphQL et
définir une nouvelle requête. Et nommez cette requête, obtenez des chambres. Et il n'
acceptera aucune entrée, mais il renverra
un tableau d'objets. Sauvegardons ce schéma GraphQL
et générons les types pour
les résolveurs à l'aide de la commande
NPM run generate. Très bien, fermez le
terminal dans la pièce, ce fichier GraphQL, puis
retournez aux résolveurs de la pièce. Et ici, sous la mutation, je vais définir une requête. Définissez ensuite le résolveur de Get
Rome. Et nous allons obtenir un parent, une
entrée vide et le contexte. Et ici, nous devons
authentifier l'utilisateur. Copions donc ceci
et collons-le ici. Nous devons maintenant créer
une nouvelle méthode
au sein du room service qui
récupérera toutes les chambres pour nous. Donc, en haut,
créez une nouvelle méthode asynchrone
et nommez-la, obtenez tous les groupes. Et nous allons obtenir toutes les
chambres pour un utilisateur spécifique. Nous allons donc accepter ici un identifiant
utilisateur de type numéro. Et nous allons utiliser le générateur
de requêtes pour récupérer les relations entre
les utilisateurs,
puis renvoyer toutes les salles dont un
utilisateur possède cet identifiant utilisateur. Définissons donc d'abord le générateur de requêtes à partir
du référentiel de la salle. Créez Query Builder et
choisissez une salle d'alias. Et puis, ici,
utilisons l'éditeur de requêtes. Je vais donc retourner
08 Query Builder. Ensuite, nous allons joindre
les tables des utilisateurs à l'intérieur la pièce qui
appartiennent à la table de chambre. Voici donc la jointure interne,
rejoignez les tables de relations
et sélectionnez des utilisateurs arrondis. Et nous allons faire référence
au tableau des utilisateurs
par la lettre U. Et puis ici, nous allons
utiliser le mot condition. Et nous allons sélectionner
toutes les salles dont l'utilisateur a un identifiant
égal à un identifiant variable. Nous pouvons définir l'ID
variable ici, SAT, cet ID d'objet
est égal à l'ID de l'utilisateur. Ensuite, nous aurons
de très nombreuses chambres. Nous allons donc l'
utiliser, en obtenir plusieurs. heure actuelle.
Sauvegardons ceci et revenons aux résolveurs de chambre contenus
dans la requête get room. Nous allons reprendre un poids. Room service, obtient tous les itinéraires et transmet
l'ID utilisateur à partir des contextes, CurrentUser, puis l'ID utilisateur.
36. Tester graphql enpoint: Il est maintenant temps de tester nos API. Assurez-vous donc que la base de données
Postgres est en cours d'exécution. Et vous pouvez le faire
à l'aide de cette commande. Assurez-vous d'exposer
les ports appropriés. Ensuite, venez ici et lancez npm. Exécutez et démarrez. Très bien, passons maintenant
à un bac à sable pour le polo. Assurez-vous de vous
inscrire et de copier le
jeton JWT dans les paramètres de
connexion et dans l'en-tête
d'autorisation. Maintenant, mutation silencieuse,
nous allons tester la mutation d' envoi de message. Mais nous devons d'abord créer un autre utilisateur
à qui envoyer un message. Oui, allons-y. Renvoyez la
mutation d'inscription
à l'utilisateur à l'e-mail et au
prénom et lancez l'inscription. Cette fois,
nous n'allons pas
copier ce jeton JWT dans
l'en-tête d'autorisation car nous devons
nous authentifier en tant que premier utilisateur
ou en tant que l'un de ces utilisateurs. Oui. Nous avons donc ici l'utilisateur avec id2
et nous allons lui
envoyer un message
avec le, avec son AD. C'est donc clair. Cela supprime la
mutation d'inscription et supprime l'entrée. Cliquez sur Envoyer un message. Et la mutation du message d'envoi. Nous allons obtenir les identifiants des utilisateurs et les messages de la salle. J'ai donc dit les utilisateurs. Prenons le premier, le
prénom et l'identifiant. Ensuite, pour les messages qui correspondent au champ du formulaire ou à partir du
champ, puis au contenu. Bien, maintenant, pour les entrées, nous devons ajouter le
message et l'identifiant de la chambre. Mais nous n'avons pas
encore de chambres dans notre base de données. Ce que nous devons
faire, c'est
créer une salle avant d'
envoyer le message. Ajoutons donc la création
par mutation et ajoutons. Permettez-moi d'abord de clarifier tout cela. Ensuite, nous avons ajouté «
créer une chambre » ou tous les champs » ici. Et pour les utilisateurs, vous obtiendrez l'identifiant
et le prénom, les messages
qui nous les enverront. Nous ne nous soucions pas de tout
cela à partir d'un simple message. Même ici, nous allons envoyer
un message à un utilisateur. Oui. Permettez-moi de vérifier quels
champs nous avons à côté, les messages ont du contenu. Maintenant, revenons en arrière.
Et les entrées. Permettez-moi d'effacer tout ce
message et d'ajouter le récepteur. Le destinataire sera un utilisateur avec id2 et le message sera un simple
texte, comme un message texte. Maintenant, envoyons ou créons la
salle et envoyons le message. Très bien, nous avons ici l'objet de la
chambre avec l'identifiant 1. Et nous avons toute une gamme d'utilisateurs. Oui, et nous avons l'
identifiant de l'utilisateur. Oui, FirstName en est un, et le deuxième utilisateur
dans cette pièce. Ces deux utilisateurs
peuvent donc désormais s' envoyer des messages. Nous avons ici le
tableau des messages avec un seul message. Et ce message a été
envoyé par l'utilisateur avec l'ID1. Donc, celui de l'utilisateur. Maintenant, si nous essayons de
créer une autre pièce avec
le même identifiant de récepteur, nous devrions obtenir un message d'erreur indiquant
que cette pièce existe déjà. Voyons donc si cela fonctionne. Très bien, nous avons donc
la salle de message
qui existe déjà et nous pouvons y aller en toute sécurité. Donc, la prochaine mutation que
nous allons tester, c'est le message du sable. Permettez-moi donc d'effacer toutes ces entrées et d'ajouter la mutation d'
envoi du message. Nous allons nous faire
une idée de la pièce, l'identifiant de l'utilisateur et du prénom de l'utilisateur. Ensuite, nous recevrons
également les messages ici. Je vais obtenir le
champ de provenance, le champ de contenu. Et puis pour les entrées, nous devons ajouter une entrée de message,
Iran, ma saisie D va
envoyer un message à la pièce, identifiant un. Et ajoutons un message, un autre message de test,
puis envoyons un message. Et on y va. Nous
avons la même salle, un document de chambre avec
les mêmes utilisateurs. Et ici, nous avons ajouté un autre message
au tableau des messages. Et user2 peut également envoyer
des messages à cette salle, mais nous devons nous connecter
en tant qu'utilisateur pour le jeton JWT soit ajouté à l'en-tête d'autorisation,
puis envoyer le message. Faisons-le très rapidement. Donc une mutation soudaine. Laissez-moi clarifier tout cela. Et lors de la mutation de connexion, je n'obtiendrai que le jeton JWT. Alors, ici, supprimez ce jeton JWT. Pour les entrées, nous avons besoin de
l'e-mail et du mot de passe. Tout ça. L'e-mail de l'unité de
fusion 2 est donc utilisé pour ajouter email.com et le
mot de passe est password. Maintenant, connectons-nous. Et n'oubliez pas que nous allons
envoyer un message à la chambre ID1. Prenons donc le jeton JWT ajouté à l'en-tête
d'autorisation. Et en sécurité. Maintenant que nous sommes connectés en tant qu'utilisateur, revenons à la mutation,
supprimons le signe de toute mutation
et connectons les entrées. Et voici la mutation d'envoi du
message. Je vais me faire
une idée de la pièce, l'idée des utilisateurs, peut-être aussi le prénom. Et je vais recevoir
tous les messages. Très bien, ajoutons les entrées. La saisie du message,
la saisie de l'identifiant de la chambre. J'ai donc dit que nous allions
envoyer un message à mon d1. Et le message est un message d'utilisateur à utilisateur
, envoyez des messages. Et on y va. Nous avons le même identifiant de chambre, document de chambre
que l'identifiant de la chambre 1, les mêmes utilisateurs et un nouveau message dans
le tableau des messages. C'est ainsi que nous pouvons envoyer des messages
en utilisant le concept des chambres.
37. Implémenter la validation avec le validateur de classe: Nous allons maintenant ajouter la
validation à notre projet. Et pour cela, nous allons utiliser les paquets de validation de classe. Donc Sage ou un terminal npm
et un validateur de classes de style. Et si nous
allons utiliser le cluster, les données, c'est parce que les
données classifiées utilisent des décorateurs. Et nous allons utiliser le validateur de classe de
caractères dans les entités pour
vérifier si nous avons, par exemple un e-mail valide ou pour appliquer certaines conditions
au mot de passe. Donc, tout d'abord, pour valider un
e-mail de l'entité utilisateur, nous allons l'importer
depuis le validateur de classe. L'importation du
personnage se fait par e-mail. C'est donc un décorateur
que nous pouvons utiliser. Faites cuire d'autres décorateurs
de couches ici. Appliquer le décorateur à
cette propriété par e-mail. Et vous pouvez voir dans
la définition ici que ce décorateur vérifie si
la chaîne est un e-mail. Si le corps donné n'est pas une chaîne, il renvoie false car tout homme doit toujours
être une chaîne. Maintenant, pour le mot de passe, nous allons valider la
longueur du mot de passe. Oui. Il nous en faut donc un autre, le personnage qui
est le Min Nan. Appliquez-le ensuite à la propriété du
mot de passe. Alors voici longuement. Et le minimum, alors
le mot de
passe sera de six
et enregistrez le fichier. Bien sûr, vous pouvez en explorer davantage. Les caractères à
l'intérieur du cluster
que vient d'écrire le méditant sont les suivants. Et vous pouvez trouver
de nombreux caractères qui permettent valider de nombreuses
choses, comme les majuscules, comme vérifier si une
propriété est une URL ou un tableau. Et beaucoup de choses comme le fait
qu'il soit vide ou non, ou qu'il soit en majuscules ou en minuscules.
Et plein de choses, oui. Vérifiez donc tout cela et jouez avec
le validateur de classe. Nous allons maintenant apprendre
à gérer la validation.
38. Attraper les erreurs de validation: Maintenant, toute la validation des
caractères va
être exécutée lorsque nous
créerons une nouvelle entité. Et avant d'enregistrer cette
entité dans la base de données, nous allons utiliser
une autre méthode du validateur de classe pour détecter
toutes les erreurs de validation. Passons donc
au service utilisateur. Et là où nous avons créé
une nouvelle entité utilisateur, importons d'abord la méthode, validons ou rejetons depuis
le validateur de classe. Et nous allons utiliser cette méthode avant
d'enregistrer l'entité utilisateur. Ici. Attendez, validez ou rejetez. Ensuite, nous allons
valider l'entité utilisateur. Ensuite, nous allons
utiliser la méthode de capture pour détecter les vibrations
ou les erreurs de validation. Nous allons donc définir ici
un rappel qui
détectera erreurs de validation de type, de
validation, de tableau d'erreurs. Et nous pouvons importer ce type
depuis le validateur de classe. Donc, ici, portez l'erreur
de validation depuis le validateur de classe et
continuez avec le rappel. Nous allons donc générer une
nouvelle erreur GraphQL si
nous avons eu des erreurs. Oui, c'est tellement important, le GraphQL. Graphql et le renvoi d' un message d'
erreur de validation avec extension. Prorogations. Et nous allons
renvoyer toutes les flèches. Oui, avec le code saisi
par l'utilisateur. Nous sommes maintenant confrontés à deux problèmes. La première est
que le mot de passe va être harcelé. Donc, si l'utilisateur envoie un mot de passe à
trois caractères, nous obtiendrons un, nous ne validerons que
le mot de passe dangereux, qui est un mot de passe à longue chaîne. Oui. Et le deuxième problème est que même si nous générons une erreur ici, nous allons tout de même passer une commande en cours d'
exécution, en exécutant cette ligne ici, nous sauverons toujours l'utilisateur. Donc, pour éviter
que tout cela ne se produise, nous allons utiliser
la méthode alors. Et ici, dans un rappel. Nous allons prendre ce neuf. Ajouté ici. Supprimez le mot
de passe de la méthode de création et donnez simplement l'aura. Laissez simplement la
saisie d'inscription comme ça. Et nous allons modifier
le mot de passe ici. Assurez-vous que cette méthode est asynchrone car nous
allons utiliser un poids. Maintenant, lorsque nous générons le
mot de passe, le mot de passe, nous allons prendre l'entité utilisateur et modifier le mot de passe pour qu'il soit
égal au mot de passe de hachage. Très bien, maintenant nous avons
résolu le premier problème. Passons maintenant au problème, nous allons renvoyer l'utilisateur. Nous allons enregistrer l'
utilisateur et renvoyer le, enregistrer un document à partir d'ici. Et puis nous
obtiendrons un résultat ici. Ce résultat est le même
que celui que l'utilisateur peut voir ici. Le résultat est de type
utilisateur car ici nous avons renvoyé l'utilisateur à partir de là. Nous allons donc simplement utiliser la déclaration de
retour ici. Et c'est tout. Ou en fait, nous avons fait
une erreur ici. Nous ne devons pas utiliser la
méthode des chats avant la méthode d'alors. Oui, donc la
méthode de capture devrait être la dernière, la dernière méthode. Alors, ici, détectez les erreurs. Donc, si nous avons une erreur ici, nous allons
renvoyer un graphique plus tôt. Mais si nous n'avons
détecté aucune erreur, nous allons exécuter
ceci, puis revenir en arrière. Très bien, nous pouvons maintenant
enregistrer ce fichier
, puis exécuter le serveur
depuis le terminal. Alors voilà, je l'
ai déjà fait. Et vous pouvez voir que Node
Man redémarre tout en
redémarrant le serveur
parce que nous avons modifié le fichier. Et maintenant, testons notre API
sur le serveur Apollo, je parle du sandbox abordable. Nous avons donc ici notre mutation
d'inscription. Je vais donc envoyer un
e-mail valide et un mot de passe valide. Je vais donc envoyer un passe à
trois caractères et exécuter la mutation d'inscription. Et nous devrions obtenir une validation. Nous y voilà. Nous devons donc obtenir
deux tableaux ici et dire que le
tableau d'erreurs doit être un objet, cela signifie que nous avons
obtenu deux erreurs. La première erreur
concerne l'e-mail. Voici donc la propriété, le courrier électronique. Et vous pouvez voir qu'à
l'intérieur des contrats que nous avons
, sa propriété e-mail. Et avec le message, e-mail doit être un e-mail. Et pour le mot de passe de la propriété, vous pouvez voir que
le message que le mot de passe doit être inférieur ou égal
à six caractères. Nous savons donc maintenant que notre
validation fonctionne. Vous pouvez ajouter d'autres validations
à l'aide du validateur de classe. Vous pouvez désormais valider
l'entité de la pièce et jouer avec
les données de clustering. Maintenant, avant de terminer cette vidéo, je tiens à noter que si vous fermez la base de données Postgres
en appuyant sur Control C, comme ceci, vous avez n, puis vous la réécrivez à nouveau avec
la commande docker run. Vous devez fermer le serveur GraphQL par le
Control C et le réexécuter. Oui, réexécutez-le lorsque
la base de données Postgres sera prête à accepter
les connexions. Sinon, vous
obtiendrez de nombreuses erreurs et vous ne pourrez pas
travailler avec la base de données.
39. pourquoi nous devrions utiliser ScoketIo: Nous pouvons désormais envoyer
des messages entre utilisateurs, mais pour qu'un utilisateur puisse
voir le dernier message, il doit recharger
le navigateur ou, par exemple ,
ici, nous utilisons une sandbox. Nous devons récupérer toutes les
chambres afin de voir les derniers messages envoyés par
le participant à cette règle. Et vous savez que les utilisateurs n'
apprécieront pas cela, car toutes les applications de
messagerie
disposent désormais d'une sorte de mécanisme de transfert de données
en temps réel qui permet
aux utilisateurs de recevoir et de lire nouveaux messages en
temps réel sans lumière, actualiser la page ou de fermer une application et de la rouvrir à nouveau afin de récupérer les chambres et vous envoyer les derniers messages. Et c'est la fonctionnalité que nous devons implémenter
dans notre application. Nous allons donc utiliser Socket IO, une
bibliothèque très populaire qui permet communication
en temps réel entre les clients et les serveurs
Web. Vous pouvez accéder à
socket point io, lire la documentation et
voir quelques exemples. Oui, mais bien sûr,
nous allons travailler avec Socket IO dans ce projet, et nous allons commencer
dans la vidéo suivante.
40. Joindre des chambres avec socketIo: Commençons maintenant par installer le
socket IO depuis MPM. Ouvrez donc votre terminal et
exécutez npm install socket IO. Très bien,
ouvrons maintenant le module, le fichier ts et y implémentons
le serveur socket IO. Laisse-moi fermer le terminal. Le système modulaire ouvre le feu. Et la première chose à
faire est d'importer la classe de serveur
depuis le socket IL. Nous allons maintenant implémenter
le serveur socket IO dans la méthode de démarrage automatique et implémenter avec
le serveur HTTP. Nous allons donc
créer la
constante A0 et créer une
nouvelle instance de serveur, transmettre le serveur HTTP. Et maintenant, nous devons commencer à
écouter les connexions. Et nous pouvons le faire
avec la méthode on et écouter l'
événement de connexion ici, la connexion. Ensuite, nous allons
ajouter et revenir ici. Ça va avoir une prise. Et nous allons faire quelque chose
avec ce genre de gadgets. Donc, afin de pouvoir
utiliser le socket dans tous nos résolveurs, nous allons le placer
dans la requête et nous pourrons accéder à la
demande à partir de la constante ad. Ensuite, demandez et créez une propriété personnalisée,
nommez-la socket IO, et définissez-la sur le socket que nous avons
reçu du client. Nous devons maintenant ajouter la propriété socket IO à l'interface de
requête, et nous allons le faire
dans le fichier main.js. Alors ouvrons-le. Et à l'intérieur, nous allons déclarer une variable
globale ou un espace de noms. Et nous allons sélectionner
l'espace de noms express. Et à l'intérieur, nous allons
sélectionner la demande d'interface. Et ici, nous pouvons ajouter le socket IO et le rendre inutile. Et puis le socket IO
va être de type socket. Nous pouvons importer ce type depuis
le package socket IO
, puis enregistrer ce fichier et revenir au
module, le fichier ts. Et vous pouvez voir
que l'erreur est l'erreur a disparu. Maintenant. Comme nous utilisons
le concept de salles dans notre application, nous pouvons faire la même
chose avec Socket IO. Nous allons donc utiliser
le socket client pour rejoindre toutes les salles
dont dispose l'utilisateur. Ensuite, chaque fois que nous diffusons un nouvel événement dans l'une
de ces salles, et bien sûr, si j'ai une prise qui
n'a pas rejoint la salle, elle n'accueillera pas l'événement. Nous allons donc faire tout
cela dans le contexte. Et ici, nous
devons vérifier si, si nous avons une charge utile. Oui, si c'est le cas, nous allons récupérer toutes les pièces
de la base de données. Pour ce faire, nous devons créer une constante ici et obtenir l'instance
source mise à jour. Alors, ici, créez notre source de données. Et nous allons l'
utiliser pour adapter toutes les pièces. Donc, ici, dans Data Source, gestionnaire de
points, je vais utiliser le gestionnaire puis le référentiel
Git. Et nous allons obtenir
le référentiel de la chambre. Importez donc l'
entité de pièce et utilisez-la ici. De la place pour ça à partir d'ici. Et transférez l'entité de la pièce. Depuis le dossier des chambres situé
à l'intérieur de la pièce. Sélectionnez les entités NSAID,
comme l'entité de chambre. Maintenant, nous utilisons la pièce pour
sélectionner le référentiel de la salle. Ensuite, nous utiliserons, nous créerons un générateur de requêtes, un alias pour la salle. Ensuite, nous allons sélectionner toutes les salles qui
contiennent le nom d'utilisateur. Pour cela, nous devons utiliser jointure
interne pour joindre toutes
les tables d'utilisateurs des utilisateurs
du point Rome et ajouter un
alias pour le tableau des utilisateurs. Ajoutez ensuite une
condition where ici et parcourez tous
les tableaux d'utilisateurs et ne sélectionnez que toutes les personnes dont l'ID utilisateur est égal à
la variable ID. Et nous allons obtenir
l'identifiant de l'utilisateur à partir de la charge utile, cet identifiant utilisateur. Très bien, nous allons maintenant ajouter une autre méthode
pour obtenir de nombreuses chambres. Et ici, créons une
constante et nommons-la Rooms. Et attendez le
résultat. Très bien. Nous allons maintenant obtenir
un ensemble d'objets From. Ensuite, nous allons utiliser le socket IO de la
demande pour les rejoindre. Voici donc le
socket Quest Dot IO qui se joint. Et cette méthode
va nous permettre d' ajouter des pièces à la prise. Et vous pouvez voir ici que nous pouvons ajouter une chambre individuelle
ou plusieurs chambres. Maintenant, nous avons besoin d'une
référence unique car, c'est vrai. C'est pour nous. Nous avons l'identifiant de la chambre comme
référence, mais c'est une chambre. C'est, la référence de la pièce
devrait être une chaîne. Nous avons donc ici une chaîne et nous avons ici un
tableau de chaînes. Mais comme vous le savez, les numéros des chambres sont des numéros. Nous allons donc les
convertir en chaînes de caractères. Et nous allons créer
un tableau d'identifiants de chaînes. Ici, créez un ID de pièce, puis utilisez le
tableau des pièces, cartographiez toutes les pièces et renvoyez une chaîne utilisant
la chaîne littérale, puis renvoyez le point identifiant de la pièce. Nous avons
maintenant un tableau de chaînes. Alors, transmettons-le ici. Identifiants des chambres. C'est bon,
maintenant c'est terminé. Mais ici, nous avons une erreur indiquant que la
charge utile ne possède pas propriété
d'identification utilisateur et
que la charge utile est de type chaîne ou palette JWT. Nous pouvons résoudre ce problème en
vérifiant si le type de charge utile n'est pas
égal à une chaîne. Et nous devons vérifier
si nous avons une charge utile. Oui. Ensuite, nous pouvons utiliser
la propriété ID utilisateur. Maintenant, voici comment
nous pouvons joindre des chambres. Dans la vidéo suivante, nous
allons apprendre comment transmettre des événements à un groupe spécifique.
41. Émettre des messages dans une pièce spécifique: Maintenant, pour émettre des événements, nous devons utiliser la constante IO, qui représente l'instance de
socket IO, et nous devons la transmettre
à la valeur de retour des méthodes de contextes afin de pouvoir l'
utiliser dans nos résolveurs. Donc, ici, à l'intérieur de cet objet, ajoutez A0 et enregistrez le
modèle dans son fichier. Puis, à l'intérieur du dossier de service Room
Dots. Ici, nous allons utiliser l'instance IO dans la méthode
ad message to room. Donc, ici, ajoutons
comme argument de type server et veillons à
ajouter le point d'interrogation ici. Parce que parfois,
on peut le savoir. Maintenant, pour le serveur ici, vous pouvez l'importer depuis le package
socket IO. Ensuite, après avoir mis à jour la salle et ajouté un nouveau
message au tableau de messages, nous pouvons vérifier ici. Si nous n'avons pas d'E/S,
dans ce cas, nous allons émettre un nouvel
événement en utilisant la méthode de l'image. Cette méthode
accepte maintenant deux arguments. Le premier argument est
le nom de l'événement et le second
est n'importe quel type de données. Il peut s'agir d'un tableau ou d'un objet, d'une chaîne ou même d'un json. Encore une fois, Jason
n'est qu'une corde. Nous pouvons donc nommer ici
le message de l'événement. Et pour les données ici, nous allons envoyer un objet contenant le message
et l'identifiant de la chambre. Maintenant, dans ce cas, nous allons émettre cet événement
pour tous les utilisateurs connectés. Mais ce n'est pas ce que nous voulons. Nous voulons transmettre ce
message à une règle spécifique. Nous allons donc utiliser une autre méthode ici
avant qu'ils n'émettent. Cette méthode est la méthode qui transmet l'
identifiant de la salle sous forme de chaîne. Utilisons donc la
chaîne littérale et ajoutons l'identifiant de la chambre. Maintenant, nous allons transmettre ce
message, cet événement, à seulement deux utilisateurs qui ont
participé à cette salle. Maintenant, sauvegardons ça. Et à l'intérieur de la pièce qui résout et à l'intérieur du résolveur d'
envoi de messages. Nous allons passer l'IO ici au-delà de l'AL à partir du
contexte I0. C'est ça Maintenant, sauvegardons
ceci et c'est l'APR.
42. Tester le serveur Io socket: Nous ne pouvons pas écouter les événements
à l'aide du sandbox Apollo. C'est pourquoi j'ai créé une
application très simple qui permet envoyer et de recevoir des messages
en écoutant les événements. Et toute cette logique se trouve
dans le fichier index.js. Vous pouvez voir ici que je me
connecte au serveur. Et voici quelques requêtes et mutations pour envoyer le message. Et ici, j'écoute
l' événement Connect et
l'événement avec messages. Et comme vous pouvez le voir ici, j'analyse les données
dans le document HTML. Donc, pour faire fonctionner ce serveur, vous devez disposer d'une extension
appelée Live Server. Vous devez donc
rechercher ici l'extension du
serveur live
et l' installer dans votre VSCode. Ensuite, vous constaterez que vous obtiendrez un bouton ici.
Laisse-moi me déconnecter. Oui, vous trouverez un
bouton qui dit Go Live, cliquez dessus, et vous
aurez un serveur en direct. Permettez-moi donc de relancer le serveur et de commencer à tester
l'application. Ça y est, c'est
la simplification. Je n'ai qu'un endroit où je dois mettre le
jeton JWT et me connecter. Ensuite, ici, nous
enverrons les messages. J'ai deux navigateurs ici, donc deux instances de
la même application. Nous devons maintenant activer le
cours dans le serveur socket IO afin de pouvoir nous connecter
à l'aide de cette URL. Alors copiez ceci. Et puis ici, dans le
module, dans le fichier ts, et dans le serveur Stockdale, ajoutons un nouvel objet et
définissons l'option de cours. Définissez l'origine de
cette URL et enregistrez-la. Revenons ensuite ici
et vérifions-nous que vous avez redémarré votre serveur. Et nous allons récupérer le jeton
JWT depuis le sandbox. Alors, assurez-vous de vous
connecter, puis de prendre le jeton JWT et de le copier, puis de le coller dans l'une
de ces applications. Cliquez sur Se connecter. Ensuite, je me suis connecté en tant qu' autre utilisateur et j'ai
enregistré le jeton. Je vais donc le coller ici. Assurez-vous de faire de
même. Cliquez sur Se connecter. Maintenant, testons le serveur,
montons dans le sable
et ça n'a pas marché. Et c'est parce qu'
ici, d'accord, nous devons supprimer la boue
à la fin de l'URL. Revenons donc au
module, les larmes au loin. Retirez la boue et assurez-vous que le
serveur a redémarré. Attendons et testons à nouveau. Très bien, vous pouvez
voir que nous sommes maintenant connectés car nous avons
le message connecté ici. Maintenant, si je clique sur le sable, nous devrions monter là-haut. Et là, peut-être devons-nous
recharger l'application. Copions donc le jeton JWT,
rechargeons , puis cliquons à nouveau
sur Se connecter. Et peut-être la même
chose ici parce que nous
devons rejoindre les chambres. Et avant, je pense que nous
ne faisions pas cela sur le serveur. Alors connectons-nous et envoyons un message. Très bien, nous avons reçu le
même message dans les deux instances qui s'
envoient ici comme un bonjour. Et voilà, notre
application fonctionne. Comme je l'ai dit au
début de cette vidéo, vous trouverez le code source joint afin que vous puissiez le
télécharger et le tester par vous-même.
43. Migration de bases de données avec typeorm: Nous avons maintenant terminé le
développement de notre API, mais nous devons encore
gérer une chose
, à savoir la mise à jour de nos entités. Dans ce cas, nous devons également
mettre à jour notre base de données. Donc, par exemple si vous voulez changer
FirstName en nom uniquement, nous devons bien
sûr
mettre à jour nos fichiers, mais surtout, nous devons mettre
à jour nos tables de base de données. Maintenant, si nous le vendions pour accélérer la mise en production de
notre projet, y compris la
base de données. Nous n'avons donc
aucune donnée d'importation. Nous pouvons fermer la
base de données et la
réexécuter afin de supprimer toutes les tables et d'en
créer de nouvelles. Mais si nous avons déjà lancé notre
projet en production nous avons des utilisateurs actifs, par exemple que
nous avons des utilisateurs actifs, par exemple dans ce cas, nous ne devons pas suivre la première
approche, car nous ne voulons pas perdre
toutes les données de nos utilisateurs. Et ce sera également un
gros désastre pour notre application. Donc, ce que nous devons faire ici, eh bien, la source de données de l'application, propriété est
synchronisée, est définie sur true, signifie que nous allons mettre
à jour nos
tables de base de données chaque fois que vous apportez
une modification à nos entités. Cette substance ne
modifiera que noms et les types de certaines colonnes, mais elle ne
préservera aucune donnée. Cette option est donc
aussi dangereuse que fermer la base de données
et de la réexécuter. Bref,
le seul moyen de prévenir la perte de données
est d' utiliser ce que l'
on appelle la migration de base de données. Il existe de nombreuses
façons de le faire. Mais avec le type ramp, nous pouvons générer
automatiquement des fichiers contenant des requêtes secrètes qui seront
responsables de l'intégration. Donc, dans un sens, l'
option de synchronisation est fausse et sûre. Et vous devez vous
assurer que nous avons une base de données active à l'aide
de la commande Docker. Et nous devons faire fonctionner notre serveur pouvoir créer les
tables utilisateur et les types de fichiers. Très bien, passons maintenant à
l'entité utilisateur et changeons prénom en nom, puis
générons une migration. Alors voici, nommez, enregistrez ceci, et mettons à jour
le schéma GraphQL ici, de FirstName à name. Et pareil,
site,
type d'utilisateur , prénom, tunique, Enregistrer. Et ici, nous allons
générer le schéma. Cela a échoué parce que nous avons
dû le générer nous-mêmes. Donc, ici, npm run generate
, puis nous allons relancer
le serveur. Très bien, NPM commence. Maintenant, nous n'allons pas
mettre à jour la base de données
car l'
option de synchronisation est définie sur false. Nous allons donc
attendre le serveur ici, puis nous allons générer
les fichiers de migration. Très bien, maintenant,
ouvrons un autre terminal. Et pour générer la
négation de Phi, nous devons
installer ce programme globalement
dans notre projet à l'
aide de cette commande. Oui. Et parfois, vous devez ajouter le mot clé pour
obtenir des privilèges d'administrateur. Et si vous êtes sur une
machine Windows et que vous devez ouvrir une console d'administration. Je ne vais donc pas le
faire parce que je suis déjà sur Start Type Ramp dans le monde entier
dans mon système. Je vais donc passer
à l'étape suivante, qui consiste à utiliser le NP x, qui est un package fourni
par défaut sans GS ni NPM. Et je vais faire circuler des
cassettes en utilisant le nœud ts et le
module CommonJS pour JavaScript. Et nous allons
exécuter une régression, générer
Carlin, et spécifier l'emplacement
de nos fichiers d'itérations. Je veux les sites dans le dossier source et dans un dossier Migrations. Ensuite, nous obtiendrons des fichiers avec horodatage et mot clé de migration. Nous allons donc obtenir des
fichiers avec horodatage, est-ce que la régression est un point Oui. Bien, nous devons maintenant spécifier l'emplacement de la source de données de
l'application. Donc, voici la source de données
néerlandaise qui, oui, c'est tout. Exécutons cette commande.
Et nous y voilà. Nous avons réussi à générer les
combats en matière d'immigration ou un seul fichier. Dans ce cas. Ce fichier est un fichier TypeScript avec une classe. Et ici, vous pouvez voir le nom,
la durée et l'horodatage. Ensuite, nous avons ici deux
méthodes de haut en bas. La méthode add sera donc
exécutée à chaque
fois que nous exécuterons cette migration. Et nous allons exécuter cette requête de suite qui
changera le prénom en nom. La méthode down peut maintenant être utilisée pour inverser les immigrations,
comme représenté ici. Vous pouvez voir la requête ici qui changera le
nom en FirstName. Donc, si nous changeons d'avis et
que nous voulons inverser la tendance de l'immigration, nous pouvons appliquer la méthode de la ville. Et bien sûr, tout
cela sera
exécuté automatiquement à l'aide du type RAM CLI. Maintenant, pour exécuter cette régression, il existe deux manières de procéder. Tout d'abord, nous pouvons utiliser la même
commande ici mais modifiée. Juste quelques éléments, comme
conserver la source de données déplacer ces neuf données ici et
modifier votre débit pour qu'il fonctionne. C'est ça. Et nous pouvons gérer l'
immigration et nous
allons obtenir une base de données mise à jour. C'est possible, ou vous
pouvez exécuter
automatiquement la migration depuis ou depuis une bande depuis ou depuis une bande en utilisant
la source de données ici. Et en y ajoutant l'immigration, l'immigration est une propriété gérée. Et nous allons préciser
où se situent nos migrations. Donc, parce que le ténia
ne peut pas faire fonctionner Ts vice, évidemment. Nous allons donc pointer vers le dossier dist qui contient
les migrations GS, Fats. Donc voici, puis la source, puis dans le dossier
des émigrations. Ensuite, exécutez tous les fichiers dont la migration est néerlandaise étaient gs et se terminent par l'extension
dot js. Oui, alors sauvegardons ça. Et en fait, ce ne sont pas des migrations, mais des intégrations de
boutons Exécutez. C'est ça. Nous allons utiliser l'exécution des
immigrations pour spécifier que nous voulons exécuter toutes les migrations lorsque
nous exécutons ce serveur. Donc, ici, c'est vrai. Maintenant, enregistrons cela et allons voir si notre
serveur redémarre. Très bien, maintenant
essayons de nous inscrire. Et cette fois, nous n'
allons pas utiliser FirstName, mais nous allons simplement
ajouter un nom. Juste ici, dans le
bac à sable, le bac à sable Apollo. Accédez à une mutation et sélectionnez
la mutation d'inscription. Alors, inscrivez la
mutation et
attendez le jeton JWT ou les entrées. Et vous pouvez voir ici que
nous avons mis à jour l'équipement graphique, mais cela ne signifie pas que nous avons également
mis à jour la base de données. Mais nous allons vérifier
cela dans une minute. Oui. Ajoutons
tout cela ici. Et laissez-moi développer cela. Très bien, choisissez n'importe quel e-mail. Email, email.com, nom de famille, nom
d'utilisateur, disons John. Mot de passe Mot de passe
Inscris-toi. Et nous devrions obtenir le jeton JWT. Si nous avons
mis à jour la base avec succès
et que nous l'
avons fait avec succès, nous avons ici le jeton JWT, et nous avons un utilisateur dans notre base de données avec le nouveau nom de propriété
au lieu de FirstName. Alors laissez-moi voir si nous pouvons
renvoyer l'utilisateur ici, d'accord, nous le pouvons, alors laissez-moi renvoyer
tous ces champs. Et je vais m'inscrire
avec un autre e-mail, peut-être un utilisateur en a un, et c'est tout. Inscris-toi. Nous y voilà. Nous avons ici l'ensemble de
noms FirstName. Nous avons donc mis à jour avec succès notre base de données en utilisant
l'immigration. C'est ainsi que nous pouvons le faire. Mais assurez-vous de toujours
le définir sur false. Ou il peut simplement
le supprimer d'ici. Je vais le garder
juste pour vous rappeler que cette propriété
doit être fausse. Et pour les immigrations, nous devons toujours
exécuter des fichiers GFS. Et vous pouvez voir dans le dossier
dist que nous avons un dossier
d'immigration. Ici, nous
avons deux fichiers pour
l'immigration. Et c'est parce que j'ai testé cette API et que j'ai essayé d'
exécuter la migration. Mais lorsque nous avons plusieurs niveaux, des fichiers de migration et que
vous les supprimez ici, cela
ne signifie pas qu'ils seront supprimés du dossier dist. Assurez-vous donc toujours de supprimer
le dossier dist ici et générer un nouveau à chaque fois que vous exécutez l'API. Sinon, vous exécuterez tous les fichiers d'intégration et vous corromprez
votre base de données. Et n'oubliez pas de
faire de même. Le site a supprimé les immigrations car nous les avons déjà
exécutées. Mais si vous le souhaitez, vous pouvez conserver les fichiers d'immigration
dans un autre emplacement. Oui. Pas forcément. À côté du dossier du projet. Dans ce cas, vous pouvez utiliser la méthode
descendante pour annuler l'immigration
si vous le souhaitez. Oui. Donc, pour nous, ce n'est pas
grave, car nous changeons simplement FirstName en nom. Je vais donc supprimer tout
ce dossier. Et c'est tout. Désormais, chaque fois que nous souhaitons
migrer la base de données, nous obtenons de nouveaux fichiers et les exécutons à partir de la source de données
type around. Maintenant, avant de terminer cette vidéo, je tiens à mentionner une
chose : si vous souhaitez exécuter les migrations
à l'
aide de cette commande, vous devez avoir la
propriété migrations dans la source de
données, n'est-ce pas ? Et vous pouvez ajouter des immigrations, les exécuter ou simplement les supprimer à partir de là. Est-ce important ? Mais pour exécuter cette commande, vous devez disposer de la propriété
immigrations et spécifier l'emplacement des migrations. Et c'est tout.