Transkripte
1. Apollo Graphql ad: Haben Sie die traditionellen
Rest-APIs satt und möchten
die neuesten
und besten RPA-Entwicklungen lernen die neuesten
und besten RPA-Entwicklungen Sie in
unserem GraphQL-Kurs genau richtig. In diesem Kurs
lernst du alles, was du
wissen musst , um
mit Graff-Girls zu
beginnen, angefangen mit den Grundlagen des Aufbaus einer Graciela
BI mit Express. Aber wir hören hier nicht auf. Wir werden uns eingehender mit der Verwendung eines Grenzservers mit
TypeScript und Express, Arbeit mit dem Typ RM und der Verwendung Postgres-Datenbank mit Docker befassen. Unser Kurs ist nicht dazu
gedacht, die volle Grafikpflege zu kosten, aber er vermittelt Ihnen
alles Wesentliche. Du lernst etwas
über Graff-Girls, Halo-Typen, Abfragen,
Mutationen, Schemas und wie man Schemas und
Resolver mit einem
Foto zusammenführt . Mädchen lernen
auch TypeScript und Cover Socket IO und eine
Datenbankmigration mit Windel. Und am Ende des Kurses werden
Sie in der Lage sein, selbstbewusst Ihre eigene GraphQL-API zu erstellen und mit einigen der neuesten und
leistungsstärksten Tools
der Branche zu
arbeiten . Worauf warten Sie noch
, dann rudern Sie jetzt für unseren Golfplatz Gail und bringen Sie Ihre
API-Entwicklungsfähigkeiten auf die nächste Stufe.
2. Einführung in Graphql: Hallo und willkommen zu dieser
ersten Lektion über Graph Gear. In dieser Lektion
stellen wir Dr. Gale vor, besprechen Abfragen und Mutationen und erklären, was ein Schema ist. Also, was ist GraphQL? Graphql ist eine von Facebook
entwickelte Abfragesprache und Runtime für APIs. Es ermöglicht Kunden,
genau das zu fragen , was sie benötigen,
und nichts weiter. Machen Sie es zu einer leistungsstarken Alternative
zu herkömmlichen Rest-APIs. Eines der Hauptmerkmale von Graph Gil ist die Abfragesprache. Die Abfragesprache
ermöglicht es Kunden genau anzugeben,
welche Daten sie benötigen, einschließlich verschachtelter Datenstrukturen und alles
in einer einzigen Anfrage abzurufen. Dadurch ist es für
Clients sehr effizient ,
Daten vom Server abzurufen. Da sie nicht
mehrere Anfragen stellen müssen , um
alle benötigten Daten zu erhalten. Lassen Sie uns ein bisschen
mehr über Abfragen sprechen. Beim Golf. Gayo, eine Abfrage
fordert Daten an. Es gibt das Feld an,
das der Client abrufen möchte, sowie alle erforderlichen Argumente
. Hier ist ein Beispiel für eine
einfache Abfrage in GraphQL. In dieser Abfrage fragen wir nach den Namens- und E-Mail-Feldern für
den Benutzer mit der ID 123 Die Antwort vom Server könnte ungefähr so aussehen. Lassen Sie uns nun zu Mutationen übergehen. Mutationen in GraphQL werden verwendet, um Daten
auf dem Server zu ändern. Sie ermöglichen es Clients,
Daten an den Server zu senden, um Ressourcen zu erstellen, zu
aktualisieren oder zu löschen. Hier ist ein Beispiel für eine
einfache Mutation in GraphQL. In dieser Mutation erstellen wir
einen neuen Benutzer mit dem Namen Jane Doe und senden Jane
Doe eine E-Mail an example.com. Die Antwort vom Server könnte ungefähr so aussehen. Lassen Sie uns abschließend über
Schemas in GraphQL sprechen. Schema ist ein Vertrag zwischen
dem Client und dem Server. Es definiert die Datentypen , die abgefragt und mutiert werden können, sowie die Beziehungen
zwischen diesen Typen. Das Schema wird normalerweise
mit der GraphQL Schema
Definition Language,
kurz SDL, definiert mit der GraphQL Schema
Definition Language, . Hier ist ein Beispiel für
ein einfaches Schema in der GraphQL-Schemadefinitionssprache. In diesem Schema haben wir einen Abfragetyp mit
einem Benutzerfeld, das ein Argument akzeptiert und ein Benutzerobjekt
zurückgibt. Wir haben auch keinen Mutationstyp mit dem Feld Benutzer erstellen, das ein Benutzereingabeobjekt erstellen und ein Benutzerobjekt zurückgibt. Binär. Wir haben einen
Benutzertyp mit ID ,
Name und E-Mail-Feldern. Das war's für diese
Einführung in das Diagramm Gail, wir haben behandelt, was Garcia ist, unsere Abfrage ist und Mutationen
funktionieren in dem Schema. In der nächsten Lektion werden
wir uns mit der
Erstellung von GraphQL-APIs befassen.
3. Arbeiten mit Graphql: Hallo und willkommen zurück
zu unserem GraphQL-Kurs. In unserem vorherigen Video haben wir die
Grundlagen von GraphQL behandelt, einschließlich Abfragen,
Mutationen und Schemas. In diesem Video
werden wir
ein einfaches Diagramm erstellen, das Gala
PI ausdrücken wird. Insbesondere
werden wir Express verwenden, um unsere
GraphQL-Anfragen und -Antworten zu bearbeiten. Und wir werden die Möglichkeiten von
Graff Girl
nutzen , um
Daten aus einer Datenquelle abzurufen. Am Ende dieses Videos werden
Sie ein solides
Verständnis dafür haben, werden
Sie ein solides
Verständnis dafür haben wie Sie die
GraphQL-API mit Express erstellen. Und Sie werden in der Lage sein,
diese Konzepte auf
Ihre eigenen Projekte anzuwenden . also ohne weitere Umschweife Lassen Sie uns also ohne weitere Umschweife eintauchen und mit der
Erstellung unseres Diagramms beginnen. Gala PI mit Express. Ich habe das
Projekt für Sie vorbereitet, damit Sie es in diesem Video
verfolgen können.
Sie können es
im Bereich Ressourcen herunterladen. Ich habe eine
Datei index.js in das Projekt aufgenommen. Diese Datei enthält
den Code, der erforderlich ist
, um nach Verbindungen mit Express zu suchen. Darüber hinaus finden
Sie eine
package.json-Datei mit drei Abhängigkeiten. Express, Express, Dutch, Graff, Girl und Graph. Hier. dies sind die wichtigsten
Tools, die wir
verwenden werden Ich würde sagen, dies sind die wichtigsten
Tools, die wir
verwenden werden, um unsere
GraphQL-API zu erstellen. Darüber hinaus wird Node Money auch im Projekt
installiert und konfiguriert. Dieses Tool startet
unseren Server automatisch neu , wenn Änderungen am Code vorgenommen
werden, was uns
viel Zeit spart und den
Entwicklungsprozess reibungsloser
macht. Bevor wir mit der
Arbeit an dem Projekt beginnen, ist
es wichtig, sicherzustellen, dass alle notwendigen
Abhängigkeiten installiert sind. Um diese Abhängigkeiten zu installieren, navigieren Sie
einfach
zum Projektverzeichnis in Ihrem Terminal und führen Sie
den Befehl npm install aus. Dadurch werden alle
notwendigen Pakete
für unser Projekt installiert . Sobald die Installation abgeschlossen
ist, können
wir mit der
Erstellung unseres Diagramms fortfahren und RPI mit Express
abrufen. In einem Graph-Gil-Projekt müssen
Sie nun als Erstes
das Schema definieren, das die
Grundlage eines Diagramms bildet. Holen Sie sich RPI, das seine
Typen und Felder definiert. Wir müssen vor
allem damit beginnen , um
sicherzustellen, dass unsere APIs klar, selbstdokumentiert,
flexibel und erweiterbar sind. Um das Schema zu erstellen, müssen
wir
die Funktion mit
dem Namen build-schema
aus dem GraphQL-Paket importieren . Erstellen Sie dann eine
Schemakonstante und verwenden Sie die
Funktion „Schema erstellen“, indem Sie
zwei Klammern öffnen und eine
Vorlagenzeichenfolge übergeben. Hier definieren wir unsere erste Abfrage, indem wir
den Schlüsselworttyp wie diesen hinzufügen
und die benannte Abfrage hinzufügen. Dann öffne zwei lockige Klammern. Und hier können wir unsere Abfragen
definieren. Also definiere ich
eine einfache Abfrage hallo. Dann müssen wir den
Rückgabetyp dieser Abfrage definieren. Fügen Sie dazu einen Doppelpunkt geben Sie
dann den Rückgabetyp an. In unserem Fall gibt
die Hello-Abfrage eine Zeichenfolge zurück.
Achten Sie darauf, ein S in Großbuchstaben hinzuzufügen. Ihre Typen werden verwendet, um
die Struktur der Daten zu definieren, einschließlich skalarer Typen
wie Zeichenketten, Ganzzahlen und boolesche Werte
sowie Objekttypen, die aus einer
Sammlung von Feldern bestehen. Um nun
Anfragen zu bearbeiten ,
die an die Hello-Abfrage gestellt werden, müssen
wir
einen Root-Resolver definieren. Das Root-Resolvable
ist dafür verantwortlich die
in der Abfrage oder
Mutation
angeforderten Daten abzurufen und sie in der durch
das Schema definierten richtigen
Form an den Client zurückzugeben . Im Wesentlichen fungiert der
Root-Resolver
als Brücke zwischen der API
und ihren Datenquellen, was ihn zu einer wichtigen Komponente
jedes Graph Girls oder PI macht. Um nun diesen
Routenresolver zu definieren, erstellen
wir eine
Routenkonstante wie und setzen ihren
Wert auf ein Objekt. Und dieses Objekt, wir müssen
alle unsere Abfragen mit demselben
Namen hinzufügen , der im Schema geschrieben ist. Also füge ich hier eine
Hello-Eigenschaft hinzu,
die die Hello-Abfrage darstellt , und setze ihren
Wert auf eine Pfeilfunktion. Übrigens sollte jede Abfrage oder
Mutation eine Funktion sein. Lassen Sie uns jetzt einfach eine Hello World-Nachricht
zurückgeben. Jetzt müssen wir in unserer API
Raphael und Buoyant definieren. Das können wir mit Express machen. Es ist also ähnlich wie bei
der Definition von Middleware. Sagte der Endpunkt
, um Graff Girl zu zerschneiden. Und für den Request-Handler verwenden
wir eine andere Funktion
namens Dr. Gil HTTP. Wir können es aus
dem Paket Express importieren ,
das ist GraphQL. Jetzt hier drinnen werden
wir
die
GraphQL-HTTP-Funktion wie folgt verwenden . Ein Objekt als Argument. Der Betreff wird unser Schema
enthalten. Sie können es so einstellen oder nur das Namensschema
und JavaScript, wir werden wissen, dass wir uns
auf das konstante Schema beziehen. zweite Eigenschaft ist die
Stammwerteigenschaft, die
unseren Root-Resolver enthält. Und die letzte Eigenschaft
ist Graffiti Girl
, ein webbasierter grafischer, interaktiver
GraphQL-Client, der es
Benutzern ermöglicht ,
mit einem GraphQL-RPI zu interagieren, indem Abfragen und Mutationen
ausführen und die Ergebnisse visualisieren. Wenn sie in
der
Express-GraphQL-Middleware-Konfiguration auf true gesetzt ist, aktiviert
die grafische Option die grafische Oberfläche zum Testen und Erkunden
unserer GraphQL-API. Nachdem das geklärt ist, speichern
wir unsere Datei, öffnen das Terminal und
führen dieses Dokument aus. Öffnen wir dann den Browser und navigieren Sie zu localhost 4.000, z. B. Scarf Girl, wo Sie die
grafische Oberfläche finden. Hier können wir unsere
Anfragen schreiben und sogar
die Dokumentation
unserer Gov Gala PR überprüfen . Hier finden Sie unsere Abfrage und darin die Hello-Abfrage, die eine Zeichenfolge zurückgibt. Wenn Sie darauf klicken, sehen Sie die Definition
des Zeichenkettenskalars. Um nun die
Hello-Abfrage von diesem Server abzurufen, müssen
wir
die Abfrage wie folgt definieren. Und erwähnte dann die
ganze Abfrage darin. Sobald Sie das getan haben, klicken Sie auf die Schaltfläche Abspielen, um die Anfrage an den Server zu
senden. Wenn alles korrekt
eingerichtet ist, sollten
Sie das
Ergebnis
der Abfragen auf der
rechten Seite Ihres Clients sehen . Gute Arbeit. In der nächsten Lektion werden
wir
diese Skala weiter untersuchen , indem wir etwas
über Mutationen lernen.
4. Mutationen hinzufügen: Lassen Sie uns nun eine
Mutation zu unserer API hinzufügen. GraphQL-Mutation
ist also eine Möglichkeit,
Daten auf dem Server
mithilfe der GraphQL-API zu ändern . Es ermöglicht Clients,
die Anfrage an den
Server zu senden , um Daten zu erstellen, zu
aktualisieren oder zu löschen. Mutationen sind im
GraphQL-Schema definiert und können
ausgeführt werden , indem eine
Graffiti-On-Mutationsabfrage an den Server gesendet wird. Definieren wir also die
Mutation, indem wir
zum Schema gehen und einen neuen Typ hinzufügen. Und ich habe eine Mutation
mit einem großen M getroffen. Und nehmen wir an, wir
möchten, dass der Client hier
Produkte zu unserer
Serverseite hinzufügt . Das ist ein hinzugefügtes Mutations-Handle
mit dem Namen Produkt hinzufügen. Dieser Handler akzeptiert einen Namen als Argument
vom Typ string, wiederum mit einem großen S und
einem Preis vom Typ int, der sich auf eine Ganzzahl bezieht. In Growth Gil steht
der Typ int also für eine numerische
Sinuszahl von 32 Byte. Es wird verwendet, um
Felder zu definieren, die Ganzzahlwerte
im Diagramm G 0-Schema zurückgeben oder akzeptieren. Dann kann type verwendet werden, um die
Typvalidierung für
GraphQL-Abfragen und -Mutationen zu erzwingen und
sicherzustellen, dass nur
gültige Ganzzahlwerte als Argumente bereitgestellt
werden. Wir können diesen
Typ
nach Bedarf definieren , indem wir ein
Ausrufezeichen davor setzen. Wir können dasselbe
für das Namensargument tun. Ordnung, jetzt müssen wir
einen Rückgabetyp für diese Mutation definieren . GraphQL-Mutation benötigt also einen Rückgabetyp, um
die Form der Daten
anzugeben , die nach
der Ausführung der
Mutation vom Server zurückgegeben
werden . Also um das zu tun, oder den Doppelpunkt
hier und füge ein Array hinzu, weil wir ein
Array von Produktobjekten zurückgeben wollen. Und um den Typ
dieses Produktobjekts zu definieren, fügen
wir hier einen anderen Typ hinzu und nennen
ihn Produkt wie. Also. Dieses Produkt
enthält einen Namen vom Typ String mit einem
Ausrufezeichen , damit er erforderlich ist. Drücken Sie dann die Eingabetaste, um
zur nächsten Zeile zu gelangen , und
stellen Sie sicher, dass Sie hier
kein Komma hinzufügen , da dies in
Driftkiemenschemas nicht zulässig ist. Die zweite Eigenschaft ist der
Preis vom Typ Integer. Wir können den Rückgabetyp auch erforderlich festlegen, um zu
verhindern, dass als Ergebnis eine Null zurückgegeben wird. Wir können das tun, indem wir
vor dem Produkt
und dem Array selbst ein
Ausrufezeichen hinzufügen. Wir können auch
die Art und Weise ändern, wie wir
unsere Mutationsargumente aufgelistet haben ,
und sie durch
ein Argument ersetzen und es als Eingabe benennen und seinen Typ so festlegen, dass es durch direkte Eingabe
hinzugefügt wird. Dies ist ein benutzerdefinierter Typ, kein integrierter Typ von GraphQL. Deshalb müssen wir es selbst
definieren. Wir bezeichnen ihn als Eingabetyp. In GraphQL ist der Eingabetyp also ein
spezieller Typ, der für Argumente
in Mutationen und Abfragen verwendet wird. Er
wird verwendet, um
die Form von Daten zu definieren , die
als Eingabe pro Feld akzeptiert werden können. Der Eingabetyp kann
skalare Typen wie
string into oder Boolean
sowie andere Eingabetypen enthalten , sowie andere Eingabetypen komplexe
verschachtelte Strukturen
ermöglichen. Eingabetypen ähneln
regulären Typen und Diagrammpflege, sie können
jedoch nicht als Rückgabetyp
eines Felds
verwendet werden , um den Eingabetyp Produkt
hinzufügen zu definieren. Fahren Sie hier fort und verwenden Sie das Eingabeschlüsselwort und
fügen Sie denselben Namen hinzu. Und darin
fügen wir dieselben Argumente hinzu, den Namen des Typs string
und den Preis vom Typ int. Speichern wir nun diese Datei und kehren zur
grafischen Oberfläche zurück. Hier können wir unsere
Mutationsabfrage hinzufügen. Sie zunächst
eine Mutation hinzu, indem Sie
zwei geschweifte Klammern öffnen zwei geschweifte Klammern nämlich die Klammern und die Mutation „Produkt
hinzufügen“. Fügen Sie als Nächstes ein
Eingabeargument in ein Objekt ein, den Namen des
Produkts, auf dem SPC steht. Seien Sie dann vorsichtig mit der Preiseingabe, da Sie
Zahlen als Zeichenfolge eingeben,
eine, um zu funktionieren, da wir
den Typ auf Integer setzen die Zahlen
stattdessen
direkt eingeben, so. Das Rückgabeobjekt, wir
wollen den Namen bekommen. Und der Bryce. Wenn Sie die
Play-Taste gedrückt haben, hat es nicht funktioniert. Und das liegt daran, dass
wir
das auflösbare Produkt hinzufügen nicht
im Root-Objekt definiert haben. Das geht sehr schnell.
Fügen Sie hier ein Komma und erstellen Sie das Anzeigenprodukt
und lösen Sie unsere Beine auf. Diese Auflösbarkeit
akzeptiert also ein Eingabeargument. Aber nicht direkt so, da das
Eingabeargument innerhalb
des primären
Objektarguments namens args existiert . So können wir auf das
Eingabeargument zugreifen. Dann sollte dieser Resolver ein Array von Objekten
zurückgeben. Das ist also fest codiert und füge ein Array mit einem Objekt
mit zwei Eigenschaften hinzu. Name, wir können den Namen so
aus der Eingabe abrufen. Und der Preis entspricht dem eingegebenen Punktpreis. Dann lassen Sie uns speichern und erneut testen. Und da haben wir es. Unser Array mit einem
Produktobjekt enthält den Namen und den Preis. Wir können den Server anweisen,
nur Objekte mit
der Name-Eigenschaft zurückzugeben , indem wir
das Preisfeld von hier entfernen. Drücke auf Abspielen. Und wie Sie sehen können, haben
wir ein Array von Objekten, das nur
die Namenseigenschaft enthält. Großartig, da Sie nun
ein grundlegendes Verständnis
von GraphQL haben , machen
wir den nächsten Schritt, um Ihre
Erfahrung zu verbessern, indem wir lernen wie man eine Portal-Graph Gail
mit Express und TypeScript verwendet . Apollo GraphQL ist
ein leistungsstarkes Tool das Funktionen
wie Caching,
Fehlerbehandlung und
Schemas-Stitching bietet . Dadurch wird es
einfacher, skalierbares GraphQL-API-Eis zu erstellen , indem ein Foto Gil,
wo sie ausdrücken,
und TypeScript
kombinieren wo sie ausdrücken,
und TypeScript Sie werden die
Fähigkeit haben,
äußerst wartungsfreundliche und
typsichere GraphQL-APIs zu erstellen . Machen Sie sich also bereit, an der
Preisverleihung eines Fotos teilzunehmen, Gill, und lassen Sie uns Ihre
Fähigkeiten als Graph Girls auf die nächste Stufe bringen.
5. Typescript installieren und konfigurieren: Bevor wir uns nun mit
der TypeScript-Syntax befassen, müssen
wir zunächst den
TypeScript-Compiler installieren, der zunächst eine ovale oder
lang.org-Slash-Download-URL für TypeScript
hat. Und hier
finden Sie eine Reihe von Möglichkeiten, den
TypeScript-Compiler in
Ihr Projekt zu integrieren, je nachdem welche Tools Sie möglicherweise
verwenden. In diesem Kurs. Ich werde mich jedoch auf die NPM-Umgebung
verlassen, da ich
davon ausgehe, dass die meisten JavaScript-Anwendungen diese
heutzutage verwenden. Unabhängig davon, wo oder
wie Sie TypeScript installieren, wenn Sie noch keinen Node haben, müssen
Sie ihn installieren,
indem Sie auf js.org gehen und dann den Anweisungen folgen,
um die neueste FTC zu installieren. Wenn Sie nun npm
auf Ihrem System installiert haben, kehren
wir zur
Download-Seite von
TypeScript zurück und kopieren Sie
diese Zeile hier. Dann werden wir es in
unserem Projekt und
in unserem Terminal ausführen . Stellen Sie also sicher, dass Sie hier
ein neues Verzeichnis erstellen, VS-Code
öffnen und
npm install TypeScript ausführen. Erspart das so viel,
wenn Sie
TypeScript in Ihrem Projekt
und nur in Ihrem Projekt installieren möchten TypeScript in Ihrem Projekt . Dies bedeutet jedoch, dass
Sie TypeScript
nur in diesem Projekt
verwenden
können, wenn der Schreibtisch hier als div-Option
gespeichert nur in diesem Projekt
verwenden
können ist. Sie können das tun, indem
ich für mich TypeScript
global innerhalb des Systems verwenden möchte. Also füge ich
den Flaggenstrich g für global hinzu und
führe dann npm install aus. Und möglicherweise müssen Sie
sudo verwenden , um diesen
Befehl als Administrator auszuführen. Und wenn Sie Windows verwenden, müssen
Sie eine
neue Admin-Konsole öffnen. Jetzt habe ich bereits TypeScript und es ist global
in meinem System gespeichert. Also werde ich diesen Befehl nicht
ausführen. Und um sicherzustellen, dass Sie TypeScript
erfolgreich in Ihrem System
installiert haben , können
Sie TSE ausführen, das ist V, und Sie erhalten
die Version von TypeScript. Ich bin derzeit auf Version 443. Und es spielt keine
Rolle, ob Sie
eine höhere Version von
TypeScript haben als meine. Weil alle
TypeScript-Center , die wir in
diesem Kurs verwenden werden, mit jeder höheren
Version von TypeScript
anwendbar sein werden . Um nun
die TypeScript-Syntax
und das Projekt Selbstzweifel verwenden zu
können, müssen wir einige
TypeScript-Konfigurationen hinzufügen. Wir können das automatisch
über die TSC-Befehlszeile machen und sterben dann darin. Und wie Sie hier sehen können, haben
wir eine neue Datei in unserem Projekt mit dem Namen
ts config dot json. Also lass es uns öffnen. Und wie Sie sehen, bietet
TypeScript hier
viele Optionen. Viele von ihnen werden kommentiert , weil wir sie nicht verwenden
werden. Jetzt ist die erste
Option ohne Commit hier das Ziel, das die
Sigma-Skriptversion darstellt. In diesem Kurs werden
wir mein sechstes Script verwenden. Und wenn Sie ein wenig nach unten
scrollen, finden
Sie die
Moduleigenschaft, die auf Kommentar gesetzt ist. Ja. Das bedeutet, dass die Module und die
Compilier-Punkt-JS-Dateien sind. Wir verwenden die
Common-Tier-Syntax, da fast alle Browser dieses Modul
unterstützen. Wenn Sie jedoch möchten, dass Ihre Dateien mit moderner
JavaScript-Syntax
kompiliert werden , können
Sie versuchen, die Jahre 2015 zu verwenden, wie dieses, ES 2015. Aber wie gesagt, wir werden es in diesem Projekt
nutzen, zu uns zu kommen. Darunter haben wir nun die
Root-Eigenschaft, die
den Speicherort der Dateien angibt
, die die TypeScript-Syntax verwenden. Lassen Sie uns also den Kommentar beenden und weiter auf
die Wurzel dieses Projekts verweisen. Scrollen wir nun nach unten
zur Eigenschaft out their, die den Speicherort
der kompilierten Dateien angibt. Also lasst es uns erhöhen. Und wir möchten, dass alle unsere Dateien
unsere kompilierten Dateien sind , die
sich im Ordner dist befinden. Wir müssen
diesen Ordner in
unserem Projekt nicht manuell erstellen , da TypeScript
das für uns erledigt. Okay, das ist alles, was
wir brauchen, um loszulegen. Speichern wir also die
TS-Konfigurationsdatei und beginnen im nächsten Video mit der
Verwendung der TypeScript-Syntax.
6. Grundlegendes Typescript: Es ist Zeit, sich mit der TypeScript-Syntax vertraut
zu machen. Und dafür benötigen wir eine neue
Datei in unserem Projekt. Erstellen Sie also
eine neue Datei und nennen sie main dot ts für TypeScript. Dann beginnen
wir hier mit Deklaration einer Variablen
, nennen sie FirstName und setzen sie auf John. Jetzt haben wir einfach
normales JavaScript geschrieben. Aber wenn ich den Mauszeiger über FirstName bewege, werde
ich feststellen, dass FirstName vom Typ String
ist. Jetzt können wir
dasselbe mit reinem JavaScript finden, aber versuchen wir,
diese Variable auf fünf zu setzen. Jetzt haben wir einen Fehler. Wenn Sie den Mauszeiger über diesen Fehler
bewegen, werden Sie feststellen, dass TypeScript
sich über
den Typ beschwert oder dieser Variablen einen
Wert zuweist. Es heißt, dass die Typnummer dem Typ
Zeichenfolge
nicht zugewiesen werden kann , da fünf hier eine Zahl und John eine Zeichenfolge ist. Es
ist also so, als würde TypeScript sagen, wenn Sie diese Variable
von Anfang an einer Zeichenfolge zuweisen , müssen
Sie sie so belassen. diesem Grund ist TypeScript
hilfreich, da es verhindert, dass kleine Fehler wie dieser in unserem Projekt
auftreten. Jetzt möchten wir, dass die
Vornamenvariable immer
vom Typ string ist. Aber stellen wir uns vor, ein anderer
Entwickler kommt rein und ändert den Wert der Variablen
Vorname in eine Zahl, sagen
wir, zehn. Jetzt ist der IRS
aus der zweiten oder
dritten Zeile hier verschwunden . Aber wir haben hier
noch einen Dollar eingeführt. Firstname-Variable ist
nicht mehr vom Typ Zeichenfolge, sondern vom Typ Nummer. Jetzt fragen Sie
sich vielleicht, warum TypeScript uns
nicht darüber informiert hat, dass wir einen Fehler gemacht
haben? Nun, es ist offensichtlich, weil wir ihr
nicht gesagt haben, dass sie das tun soll. Um TypeScript
anzuweisen nur Zeichenketten
für diese Variable zu akzeptieren, müssen
wir einen Doppelpunkt
und dann eine Zeichenfolge hinzufügen. Jetzt können Sie sehen, dass
wir zwei Fehler haben. Nun, es ist derselbe Fehler, aber an zwei verschiedenen Stellen. Es hat dieselbe
Botschaft wie zuvor. Die Zahl kann der Zeichenfolge
derselben Nachricht nicht zugewiesen werden. Wir können es hier finden. Um das zu beheben, können wir einfach die Zehn
von hier entfernen und durch
eine Zeichenfolge ersetzen. John. Wir können das tatsächlich
entfernen, weil
es diese Variable ist, und diese Variable in
der dritten Zeile wie folgt
zuweisen. Und hier können wir sehen, dass
der IRS verschwunden ist. Aber lass
es uns einfach in einer Zeile belassen. Also nehme ich
das noch einmal und verschiebe den FirstName von hier
und weise ihn John zu. Wenn Sie nun
eine Zahl anstelle einer Zeichenfolge deklarieren möchten, können
wir eine weitere
Variable mit Namen und Alter erstellen, den Typ auf Zahl
setzen und uns dann bei einer beliebigen Zahl anmelden 22 wählen. Und jetzt wissen Sie
, dass Sie in diesem Fall eine Fehlermeldung erhalten, die besagt , dass die Typzeichenfolge nicht der Typnummer
zugewiesen werden kann. Jetzt haben wir nicht nur
Zeichenketten und Zahlen, wir haben auch Objekte. Lassen Sie uns also
eine weitere Hauptvariable deklarieren. Benennen Sie es LPG für ein Objekt und legen Sie es dann
auf ein Objekt fest, wobei der
Vorname der Eigenschaft auf Diagramm gesetzt ist. nun in der nächsten Zeile, Versuchen
wir nun in der nächsten Zeile,
die FirstName-Eigenschaft
einer Zahl zuzuweisen und zu sehen, was
passieren wird. Objekt FirstName entspricht also fünf. Hier können Sie nun sehen, dass
TypeScript einen Fehler hat , der besagt, dass die Typnummer Typ String nicht zugewiesen werden kann
. Und das ist zu erwarten,
da die Deklaration Objekteigenschaften der Deklaration normaler Variablen ähnelt . Und dasselbe, wenn wir
versuchen , das Objekt
der Variablen Vorname zuzuweisen, erhalten
wir den gleichen Fehler. Und dieses Mal kann der Zeittyp String nicht dem Typ zugewiesen werden als das Objekt, das wir der Variablen
von Anfang
an zugewiesen haben . Lassen Sie uns
dies nun entfernen und einem Objekt
den Variablentyp zuweisen . Jetzt können Sie sehen, dass wir
keine Fehler erhalten haben. Aber ich möchte für die Augen
klarstellen, dass es dieser beliebigen Variablen um ein Objekt
handelt, das eine
FirstName-Eigenschaft vom Typ String
enthält. können wir tun, indem wir
das Objekt von hier entfernen und es
durch
zwei geschweifte Klammern ersetzen. Und hier sind die Vornameneigenschaft
und setzen Sie sie auf den Typ Strain. Nehmen wir an, ich möchte
diesem Betreff
eine neue Eigenschaft hinzufügen , z. B. H. Wir erhalten eine Fehlermeldung die
besagt, dass dieser Typ Objekt
mit den Eigenschaften FirstName, Zeichenfolge und Altersnummer ist. Sie kann
dem Objekt nicht zugewiesen werden , das
nur die FirstName-Eigenschaft
vom Typ Zeichenfolge besitzt . Das wird jetzt
sehr hilfreich sein, wenn wir möchten, dass unsere Objekte nur
ganz bestimmte Eigenschaften enthalten. Und wenn wir
die Alterseigenschaft hinzufügen möchten,
die eine Zahl ist, können
wir natürlich die Alterseigenschaft hinzufügen möchten,
die eine Zahl ist, hierher kommen und dann das Alter der Typnummer
hinzufügen, und der Pfeil verschwindet. nun nach Zeichenketten,
Zahlen und Objekten sehen, Lassen Sie uns nun nach Zeichenketten,
Zahlen und Objekten sehen, wie wir
Funktionen mit TypeScript definieren können. Lassen Sie uns also eine neue
Funktion deklarieren und ihr einen Namen geben. Benutzer erstellen. Diese Funktion
akzeptiert zwei Argumente. erste ist der Vorname, zweite das Alter. Jetzt können Sie hier sehen, dass
wir zwei Fehler haben. Vorname oder der Parameter FirstName
haben implizit einen beliebigen Typ. Jetzt
sind Funktionsargumente auch Variablen. Und JavaScripts setzen den Typ
dieser Argumente
standardmäßig auf den Typ any. Aber TypeScript erlaubt das
nicht, also müssen wir Typen
für diese Argumente hinzufügen. Also für den FirstName addString und für
das Alter ist eine Zahl. Lassen Sie uns nun etwas
von dieser Funktion zurückgeben. FirstName plus das h zurück. Sie können sehen, dass wir keine Fehler
erhalten haben, da selbst TypeScript weiß, dass wir das Alter in
eine Zeichenfolge konvertieren und dann mit der
FirstName-Variablen
verketten
möchten eine Zeichenfolge konvertieren und dann . Wenn Sie nun das
Pluszeichen durch ein Minuszeichen ändern, erhalten
Sie eine Fehlermeldung. Da TypeScript
weiß, dass das Ausführen einer Subtraktionsoperation zwischen einer Zeichenfolge und einer Zahl nicht logisch
ist. Lassen Sie uns das alles entfernen und durch eine
literale Zeichenfolge ersetzen. Und darin haben
wir FirstName, fügen
dann die Variable Vorname
und dann age, die Altersvariable, hinzu. Erstellen Sie eine weitere Variable
und nennen Sie sie stl string. Und dann lassen Sie uns
die Funktion „Benutzer erstellen“ ausführen. Jetzt können Sie hier sehen, dass
wir zwei Argumente benötigen. Das ist also der Vorname für
John und das Alter bis 22. Wenn Sie nun den Mauszeiger über
die STR-Variable
bewegen, finden Sie sie vom Typ string. Wir können den
Rückgabetyp einer Funktion wie für eine Variable angeben, indem wir hier einen Doppelpunkt
verwenden und dann den Typ string hinzufügen. Nehmen wir nun an, ich möchte ein Objekt daraus
zurückgeben. Danke dafür. Ich werde
das mit dem Objekt ändern. Und wir erhalten eine Fehlermeldung
, die besagt , dass der Typ string dem Typ Objekt nicht
zugewiesen werden kann, aber die Variable STR vom Typ Objekt
ist. Lassen Sie uns nun diesen
Fehler beheben, indem wir
diese Zeichenfolge verschieben und durch ein Objekt ersetzen
. Der andere ist weg. Aber nehmen wir an, ich
möchte dieses Objekt
mit einer Alterseigenschaft zurückgeben , die
auf das Aids-Argument gesetzt ist. Wenn ich
den Rückgabewert
der aktuellen Benutzerfunktion verwenden möchte , bei der es sich um ein Objekt handelt, das eine Alterseigenschaft enthalten
soll. Wir erhalten eine Fehlermeldung, die besagt, dass die Eigenschaft Alter im Typ Objekt nicht
existiert. Kann das beheben, indem Sie dies entfernen, ein Objekt und die
A-Eigenschaft mit der Typnummer
hinzufügen. Wenn Sie nun mit der Maus über h fahren, werden
Sie sehen, dass es existiert
und dass es die Typnummer hat. Fügen wir auch den
FirstName in dieses Objekt ein und setzen ihn
auf das Firstname-Argument. Hier haben wir einen Fehler
, weil wir
die FirstName-Eigenschaft
zum Rückgabetyp
dieser Funktion hinzufügen müssen die FirstName-Eigenschaft
zum . Also FirstName vom Typ string. In Ordnung? Nehmen wir an, wenn wir einen Aids-Wert von mehr als 20
haben, lehnen
wir dieses Aids ab lehnen
wir dieses Aids und geben nur den Vornamen zurück. Lassen Sie uns hier also eine
if-Aussage hinzufügen und überprüfen, ob das Alter gleich oder größer ist als. 20. Wenn ja, geben wir nur ein Objekt mit
der FirstName-Eigenschaft
zurück. Jetzt möchte TypeScript mich dieses Objekt
nicht
ohne die Alters-Eigenschaft
zurückgeben lassen . liegt daran, dass wir ihr gesagt haben, dass diese Funktion ein Objekt zurückgeben wird das
nur die Alters-Eigenschaft des Typs Nummer und die
FirstName-Eigenschaft des Typs String enthält. Wir können dies beheben, indem die Alterseigenschaft als nicht erforderlich kennzeichnen, indem wir hier ein
Fragezeichen hinzufügen. Jetzt ist der Fehler weg. Und wenn Sie den Mauszeiger über Hilfsmitteln
bewegen, stellt die Eigenschaft fest, dass h vom Typ Nummer oder undefiniert ist
. Jetzt können Sie dasselbe für
die
Unzufriedenheit mit
dem Altersargument tun , aber nur, wenn dieses Argument
das letzte in den nächsten
Argumenten ist . Wenn wir nun das
Fragezeichen hier hinzufügen, erhalten
wir eine Fehlermeldung,
die besagt , dass das Objekt
möglicherweise undefiniert ist. Jetzt wundern Sie sich vielleicht, warum wir uns hier verärgert
haben, nicht Nummer. Nun, das liegt daran, dass
in JavaScript alles ein
Objekt ist, sogar Funktionen. Sie können den Typ des
Altersarguments jedoch als
Zahl oder undefiniert finden . Wenn wir die Position
dieses Arguments ändern und es hier
von Anfang an einfügen, erhalten
Sie eine weitere Fehlermeldung. Das heißt, dass ein erforderlicher Parameter einem
optionalen Parameter
nicht folgen kann. Wenn Sie hier also ein
Fragezeichen hinzufügen, der Pfeil
aus der Argumentliste verschwunden, aber Sie erhalten viele Fehler in der Funktion und außerhalb Funktion, in
der
wir ihn ausgeführt haben. Jetzt wollen wir das nicht. Wir wollen
alles so ändern, wie es war. Lassen Sie mich das also von hier entfernen, dort
platzieren und
das Fragezeichen
aus dem H-Argument entfernen . Nehmen wir nun an, wir möchten, dass
diese Funktion
die Hilfsmittel als Zahl
oder als Zeichenfolge akzeptiert . Wir können das tun, indem einen vertikalen Balken
hinzufügen und den String-Typ hinzufügen. Natürlich müssen wir dasselbe für
den Rückgabetyp
dieser Funktion
tun . Lassen Sie mich das schließen, um mehr Platz zu
haben, und hier eine Leiste mit
diesem Zeichenkettentyp
hinzufügen. Jetzt ist das Alter hier vom Typ, der Zeichenfolge, der Zahl oder undefiniert. Wir können dasselbe
für eine Variable tun, z. B. für den FirstName hier Fügen
wir entweder eine
Zeichenfolge oder eine Zahl hinzu. Oder machen wir es für das Alter. Also hier haben wir eine Nummer. Fügen wir eine Zeichenfolge hinzu. In Ordnung? Jetzt können wir die Altersvariable entweder einer Zahl
oder einer Zeichenfolge
zuweisen. So wie das.
7. Fortgeschrittenes Typoskript: Gehen wir nun zurück zur
aktuellen Benutzerfunktion und
stellen Sie sich vor, wir hätten mehr
Eigenschaften in diesem Objekt mit komplexeren Typen. In diesem Fall ist es
nicht praktisch, ein großes Objekt
vor dieser Funktion zu haben. Und um dies zu beheben, hat
TypeScript
sogenannte Interfaces eingeführt. Eine Schnittstelle ist auch ein Objekt, aber Sie können es nur
als Referenz für einen Typ verwenden. So können wir
eine Schnittstelle mit
dem Schlüsselwort interface und dann
dem Namen der Schnittstelle deklarieren . Und ich werde den Benutzer wählen. Und wie gesagt, wir werden ein Objekt erstellen, aber ohne
Gleichheitszeichen oder Spalte. Du kannst es dir als eine Klasse vorstellen. Nehmen wir nun all das,
das Alter und den Vornamen. Schneiden Sie es von dort aus,
entfernen Sie das Objekt, entfernen Sie den Doppelpunkt und fügen Sie sie hier in
diese Schnittstelle ein. Lassen Sie uns den
Code ein wenig anpassen. Sie können ein Komma hören, aber Sie können auch
ein Semikolon verwenden oder Sie können einfach alles von dort
entfernen. Aber ich möchte Semikolons verwenden , weil es auf diese Weise
organisierter aussieht. Jetzt können wir die
Benutzeroberfläche wie jeden anderen Typ verwenden. Hier der Doppelpunkt und dann
die Benutzeroberfläche. Und wenn Sie den Mauszeiger über Hilfsmittel bewegen, werden
Sie feststellen, dass
das Alter immer noch den Typ Zeichenfolge,
Zahl und undefiniert hat. Denken Sie daran, dass Schnittstellen nur
auf einen Objekttyp beziehen. Also, wenn du von
hier die
lockigen Klammern entfernst und
die Hilfsmittel einfach stehen lässt, wirst du finden. Sie erhalten eine Fehlermeldung
, die besagt, dass Zeichenfolge oder Zahl vom Typ Benutzer
nicht zugewiesen werden können,
da der Benutzer zunächst zwei Eigenschaften hat
und der Benutzer ein Objekt ist. Und nimm die Änderungen vor. Und lassen Sie uns eine weitere
Funktion erstellen und sie login nennen. Diese Funktion akzeptiert ein Argument und sie wird
den Namen login ox haben. Es wird vom Typ Login sein. Und natürlich werden wir ein Schnittstellen-Login
definieren. Lassen Sie mich also diesen Namen kopieren. Hier ist die Schnittstelle und
definiere die Anmeldeschnittstelle. Damit sich ein Benutzer anmelden kann, benötigen
Sie also eine
E-Mail vom Typ Zeichenfolge und das Passwort vom
Typ String. Eigentlich möchte ich die
Kontrolle über den Passworttyp haben,
während ich die Anmeldeschnittstelle
innerhalb der Login-Funktion verwende . Dazu können wir
die Mittelfläche so ändern, dass sie
generisch ist, indem wir zwei eckige
Klammern wie diese hinzufügen. Und dann können Sie sich diese Schnittstelle jetzt als
eine Funktion vorstellen , die
ein Argument als Typ akzeptiert. Und wir können den
Namen des Arguments wählen. Ich wähle
PWD als Passwort und weise diesen Typ für
das Passwort zu. Wenn Sie nun den
Mauszeiger über login bewegen, werden
Sie feststellen, dass für den
generischen Typ login ein Typargument
erforderlich ist. Wie gesagt, Funktionen
haben Argumente. Für den generischen Typ
gilt also dasselbe Konzept. Jetzt können wir dieses Argument definieren
, indem eine abgewinkelte Klammer
und den Typ
des darin enthaltenen Passworts als Zeichenfolge hinzufügen. Lassen Sie uns nun zur Zufriedenheit ganz schnell überprüfen, ob die
Login-Args-Punkt-E-Mail z. B. ihm erstellt wurde und das Login-Args-Passwort z. B. dem Passwort entspricht. In diesem Fall
werden wir die Wahrheit wiedergeben. Der Benutzer ist also authentifiziert. Hier, andernfalls, geben
wir Falsch zurück. Ich werde den Typ
des Rückgabewerts
dieser Funktion auf body setzen . Und das ist ein neuer
Typ, den wir verwenden können. Und es braucht keine Definition weil der boolesche Wert entweder wahr
ist. Falsch. Kehren
wir nun
zur Anmeldeschnittstelle zurück und können eine weitere Variable verwenden
, die sich nur auf
einen Typ bezieht und den
Passworttyp für uns enthält. Und weil das Passwort kein Objekt
ist, können
wir das Schlüsselwort
interface nicht verwenden. Wir können nur den
Typalias verwenden und den Typ dann als Passworttyp
benennen. Und dann können wir diese
Zeichenfolge zu diesem Typ hinzufügen. Also hier String. Dann können wir
den Passworttyp
in der Anmeldeschnittstelle verwenden . Wenn Sie den Mauszeiger
darüber bewegen, werden Sie feststellen dass der Passworttyp eine Zeichenfolge ist. Sie können hier entweder
eine Zeichenfolge oder eine Zahl hinzufügen. Und Sie können
jeden gewünschten Typ hinzufügen. Passwörter können jedoch nur Zeichenfolgen oder Zahlen
sein. Wir können den
Typalias auch verwenden, um einer Variablen oder einem
Rückgabewert einer Funktion einen Typ
hinzuzufügen . Also füge ich hier
den Typ login hinzu, das Ergebnis entspricht der Lautstärke und stelle
sicher, dass es in Großbuchstaben geschrieben ist. Und hier für den Körper, und wir können einen Kleinbuchstaben
oder einen Großbuchstaben verwenden. Es ist dasselbe. Lassen Sie uns das ändern
, um die Login-Ergebnisse zu sehen. Stellen Sie sich nun vor, wir
haben eine asynchrone Funktion. Wir werden das
Schlüsselwort async verwenden, um das zu definieren. In diesem Fall erhielten wir
eine Fehlermeldung, die besagt, dass
der Rückgabetyp
einer asynchronen Funktion
oder Methode
das globale Promise-Generikum
mit dem Argumenttyp T sein muss . Und dann sagt er: Wolltest du
diesen generischen Typ schreiben? Nun, wenn Sie JavaScript kennen, wissen
Sie, dass
eine asynchrone Funktion ein Versprechen zurückgibt. Und so können wir mit TypeScript
einen Versprechungstyp definieren . Lassen Sie uns also das
Login-Ergebnis so ändern, dass ein Versprechen
ist, da diese Funktion ein Versprechen zurückgibt. Und dann stellt das Generikum
oder das Argument dieses generischen Typs
den tatsächlichen Rückgabetyp
dieser Funktion dar , oder mit anderen Worten, den Ergebniswert oder den Typ der Auflösung
dieses Werts. Also hier lösen wir
einen Booleschen Wert auf. Und Sie können sehen, dass
der Fehler weg ist. Nehmen wir nun an, wenn wir den Benutzer
authentifizieren, senden
wir ein Objekt
anstelle von true. Und dieses Objekt wird
eine Benutzername-Eigenschaft enthalten, die John erneut
gesagt hat, und eine weitere
Eigenschaft, die auf aktiv gesetzt ist. Wir haben also einen aktiven Benutzer
in unserer Datenbank. Natürlich
haben wir hier keine Datenbank, aber stell dir vor
, wir haben eine. Jetzt bekommen
wir natürlich eine Fehlermeldung. Und um das zu beheben, fügen wir hier eine
Schnittstelle hinzu und benennen, nummerieren und zitieren. Wir werden die
Eigenschaft username vom Typ string und die Status-Eigenschaft ebenfalls auf string
setzen lassen. Und hier erhalten wir
ein Versprechen, das entweder einen
Booleschen Wert oder eine Zahl
löst. Also habe ich hier einen Fehler gemacht. Im Moment ist die Erde
verschwunden und wir können entweder
eine Kraft oder ein Objekt zurückgeben. Nun zur Status-Eigenschaft Wir können nur drei Status zurückgeben, den aktiven Status, den
inaktiven Status und den neuen Status. Also hier musst du immer eine dieser Zeichenketten
zurückgeben. Aber wenn ich so aktiv geschrieben habe, habe ich
in diesem Fall einen Tippfehler gemacht. Aber TypeScript
hat nichts gesagt. Da TypeScript nichts
über diese Zeichenketten weiß , kümmert es sich nur um den Typ
der Statuseigenschaft, die als String bezeichnet
wird. Und wie Sie hier sehen können, habe ich bereits einen Tippfehler gemacht. Wie können wir also diese
Art von Fehlern oder Irrtümern verhindern? Nun, es ist sehr einfach. Wir müssen einen Enum-Typ deklarieren. Verwenden Sie hier also die
NM-Ideen und nennen Sie
diesen Enum-Typ dann Mitgliedsstatus. Und es wird ein Objekt sein, aber es wird sich nicht auf ein Objekt
beziehen. Ich werde Ihnen in nur einer Sekunde sagen, wie wir es
verwenden können. Jetzt können wir
diese drei Typen definieren, indem aktiv und inaktiv
hinzufügen. Und dann der neue Status. Jetzt müssen wir
diese Zeichenfolge hier
durch das Status-Enum des Mitglieds ersetzen . Und dafür müssen wir die
Zahlen Status Enum auch
bis 2s verwenden Zahlen Status Enum auch , um
den aktiven Status auszuwählen. So aktiv. Sie können hier sehen, dass VSCode die drei Typen hier
als Erfolg
hat , da dies sehr
hilfreich ist , um den
Entwicklungsprozess zu beschleunigen. Wählen wir nun aktiv. Und wenn Sie den Mauszeiger darüber bewegen, werden
Sie feststellen, dass der
Status des Mitglieds , der aktiv ist, gleich Null ist. Jetzt können Sie
den aktiven Status als
Zeichenfolge bezeichnen , indem Sie gleich hinzufügen. Dann aktiv. Das Gleiche gilt für Inaktive. Hier, Zeichenfolge, inaktiv kopieren. Und für das Neue wusste es auch. Wenn Sie nun den Mauszeiger über aktiv bewegen, wird es als aktiv
genauso aktiv wie eine Zeichenfolge angezeigt. In der Mitgliederschnittstelle können
wir jetzt nur eine
dieser Eigenschaften akzeptieren. Jetzt werden wir keine Angst haben,
einen von ihnen falsch zu schreiben. Speichern wir nun diese Datei und öffnen wir das Terminal
und versuchen zu kompilieren. Wir können das ganz einfach tun, indem wir
den TSC-Befehl verwenden und
einfach die Eingabetaste drücken. Der TSC-Befehl
überprüft, ob Fehler oder
Typskriptfehler vorliegen. Und wenn dann alles in Ordnung ist, haben
wir einen dist-Ordner, der die Datei main.js
enthält. Wenn Sie es öffnen,
finden Sie hier eine Menge Code. Aber alle Typen von früher, aus der Datei main.js,
sind verschwunden und wir
haben nur reines JavaScript. Sie können sehen, wie TypeScript den Enum-Typ
kompiliert. Und hat das alles für uns getan. Schädel, der
Hauptpunkt, Punkt-JS-Datei. Und jetzt können Sie sagen, dass Sie so ziemlich
alles über TypeScript
gelernt haben. Bevor Sie das Video beenden, lassen Sie mich Ihnen kurz
zeigen, wie Sie die Anmeldemethode verwenden
können. Also hier, nimm das
Nicht-Spiel und gib das Objekt mit der E-Mail-Adresse weiter, die
auf E-Mail, Passwort, auf Passwort gesetzt ist. Und da dies eine asynchrone Funktion
ist, verwenden
wir die
Methode then, um das Ergebnis zu erhalten. Und dann werden wir überprüfen, ob der Status aktiv ist oder nicht. Und dazu erstellen
wir eine if-Anweisung und prüfen
zuerst, ob das Ergebnis eine Instanz
der Klasse Boolean
ist. Übrigens ist der boolesche Wert mit dem Großbuchstaben B Glas. Und es ist ein Strudel für den Typ Boolean mit
dem Kleinbuchstaben b. Also bezieht sich dieser Typ hier
nur auf wahr oder falsch. Aber der Boolean mit
Großbuchstabe B bezieht sich auf eine Klasse, die
den Typ Boolean enthält. Also werde ich das machen. Wenn es sich um eine Instanz von
Boolean handelt, kehren Sie zurück. Andernfalls nehme das
Ergebnis diesen Status. Prüfen. Wenn dies der Fall ist, entspricht
dieser Status einem Login oder einem Mitglied. Status aktiv. Wenn ja, kehren wir als wahr
zurück. Oder vielleicht Konsolenprotokoll. Der Benutzer ist aktiv. Der Benutzer ist aktiv. Wenn Sie nun
Text und Kleinbuchstaben verwenden möchten, ändern Sie dies und
Sie können nach
dem Typ von Boolean mit
type of keyword und dann
result equals suchen dem Typ von Boolean mit type of keyword und dann
result , um die Lautstärke
sicherzustellen. Und wenn Sie eine
solche Überprüfung mit dem Ausrufezeichen
durchführen möchten , können
Sie den
booleschen Typ von
hier entfernen und durch Null ersetzen. Und anstatt falsch zurückzugeben, werde ich Null zurückgeben. Das ist besser. Und Sie können
sehen, dass Null auch ein Typ ist. Jetzt finden Sie
diese Datei zusammen mit anderen
TypeScript-Ressourcen an
dieses Video angehängt . Sie sie also unbedingt herunter und erfahren Sie selbst mehr über
TypeScript.
8. Das graphql erstellen: Ich bin in VSCode und
hier habe ich zwei Fünfer, die TS-Konfigurationsdatei und die
Bank hat die JSON-Datei. Nun zur TS-Konfigurationsdatei, wir haben hier einige neue Optionen, zum
Beispiel, dass die Bibliothek auf Ja, 2021
eingestellt ist. Und die
Modulauflösung wurde ebenfalls
beachtet, wobei die Typen
ebenfalls zur Kenntnis genommen wurden. nun für die strikte
Eigenschaftsinitialisierung
sicher, dass sie auf false gesetzt ist, oder Sie können sie einfach
aus Ihrer TS-Konfigurationsdatei entfernen. Schließen Sie das jetzt und übrigens,
ich werde
diesem Video eine Zip-Datei hinzufügen , damit Sie sie in
den Ressourcen und Downloads finden können . Jetzt werden wir
einige Pakete von MPM hinzufügen. Also hier habe ich das
Terminal aus dem VS Code. Sie können es öffnen, indem Sie hier unter Terminal und
dann auf neues Terminal klicken. Also hier werde ich neue Pakete wie
den Express mit den
Typen für Express
installieren . Und wir werden mit dem
Apollo-Server mit Express arbeiten. Also werde ich
einen Polo Server Express installieren. Und natürlich brauchen wir GraphQL
und die Typen für GraphQL. Also hier bei Types
Slash Graph Gear. Und nur für den Fall, dass ich die Typen zur Notiz
installiere. Lassen Sie uns nun diesen Befehl ausführen und all
diese Pakete installieren. Ordnung, lassen Sie mich jetzt
dieses Terminal löschen und
im Stammverzeichnis einen neuen
Quellordner erstellen. Und hier drin haben
wir eine
Datei main.js und eine Modul-Punkt-TXT-Datei. Und im Moment werden wir
diese beiden Dateien
nicht berühren , da wir zuerst das
GraphQL-Schema erstellen müssen . Stellen
Sie dafür sicher, dass Sie sich wieder
im Stammverzeichnis befinden , erstellen Sie eine neue Datei und nennen Sie sie Schema. Dieser Raphael. Okay, jetzt hier ist das GraphQL-Schema, das
aus Mutationen und Abfragen besteht. Wir verwenden Mutationen, wenn wir Daten in der Datenbank
ändern wollen . Und wir verwenden Abfragen, wenn wir Daten aus der Datenbank abrufen möchten . Sie können
sie sich als Beiträge in
Anfragen vorstellen , wenn wir eine RESTful-API
verwenden würden. Lassen Sie uns nun unsere erste Mutation
definieren. Und dazu müssen wir das Schlüsselwort type verwenden und
dann Mutation schreiben. Und hier drinnen werden wir die Anmeldemutation
haben. Also richtig, melde dich an und melde dich an. Es wird die
Benutzereingabe akzeptieren. Also hier werden wir
die Eingabe
als Argument für diese Methode schreiben . Und wir müssen den
Typ dieser Eingabe definieren
, damit wir, wenn wir diese
Mutation mit unserer API verwenden, wissen, welche Argumente
erforderlich sind und welche nicht. Und definiere einen solchen Typ. Wir müssen hier das
Eingabeschlüsselwort verwenden, oder? , und benennen Sie dann diesen
Eingabetyp Signup input here, und stellen Sie sicher, dass Sie hier ein
großes S
für uns haben, für seinen Typ oder seine scharfe
Eingabe und es ist nicht erforderlich, aber es ist eine übliche Sache
mit GraphQL. Also hier, auf der
Anmeldeingabeseite ,
definieren wir die Anmeldeargumente. Übrigens ist die Syntax von GraphQL möglicherweise
nicht so
gefärbt. Denn wenn Sie das wollen, müssen
Sie eine
Erweiterung für GraphQL installieren. Gehen Sie also hier in den
Erweiterungsbereich und suchen Sie nach der
GraphQL-Erweiterung. Ich habe es hier schon
installiert. Stellen Sie also sicher, dass Sie
dieselbe Erweiterung installieren. Und dann müssen
Sie möglicherweise nach der
Installation dieses Pakets
eine Konfigurationsdatei erstellen . Scrollen Sie also hier nach unten und Sie
müssen eine Punkt GraphQL
fc dot YAML-Datei erstellen , diese beiden Zeilen
kopieren
und in Ihr Projekt einfügen. Und Sie können hier sehen
, dass diese Konfigurationsdatei, unser Start, auf die
älteren GraphQL-Dateien
in unserem Quellordner abzielt . In unserem Fall benötigen wir das noch
nicht, aber in Zukunft werden
wir
mehrere GraphQL-Dateien haben. Daher müssen Sie möglicherweise
auch diese Zeile kopieren und in
die Konfigurationsdatei einfügen. Und das werde ich auch auf meiner Seite tun
. Nur um sicherzugehen , dass wir das in Zukunft nicht
vergessen. Gehen Sie also zurück zu unserem Projekt
und
erstellen Sie im Stammverzeichnis eine neue Datei und nennen Sie sie Punkt GraphQL LRC als GMO. Und hier, füge den
Code hier ein und schließe ihn. Und dann haben Sie die
gleichen Stile für GraphQL. Und nicht nur Stile, sondern auch Autocomplete. Ja. Deshalb empfehle ich Ihnen , diese
Erweiterung zu installieren und zu verwenden. Immer wenn Sie ein Graph
Kill-Schema erstellen, nur um
Tippfehler und unnötiges Debuggen zu verhindern Tippfehler und unnötiges Debuggen falls Sie hier Fehler gemacht haben. Ja. Um sicherzugehen, dass ich GraphQL hier im
Stammverzeichnis habe , wir mit
der Anmeldeeingabe fort. Um einen neuen Benutzer zu erstellen, benötigen
wir also eine E-Mail vom Typ string. Und stellen Sie sicher, dass Sie hier
ein großes S haben. Und achte auch darauf, dass
du
keine Semikolons hast oder hierher kommst. Und jetzt definiere auch das
Passwort vom Typ string. Außerdem benötigen wir einen Vornamen
vom Typ String und den Nachnamen
vom Typ String. Und jetzt verwenden wir diesen Typ
hier für die Anmeldeeingabe. Und wie Sie hier sehen können, ähnelt
es dem
TypeScript, wenn es um die Definition und
Verwendung von Typen
geht. Ja. Sie haben also möglicherweise
keine Schwierigkeiten die
GraphQL-Syntax zu
verstehen, oder? Definieren wir nun den Rückgabetyp
der Anmeldemutation. Jetzt erhalten
wir bei jeder Abmeldung den Benutzer,
das Benutzerdokument
und das JWT-Token zurück . Also lasst uns das definieren. Und diesmal müssen wir das Schlüsselwort type
verwenden, da das Eingabeschlüsselwort
nur verwendet wird , wenn wir
die Eingaben für
Mutationen oder Abfragen definieren möchten . Und der Typ wird verwendet, um
hauptsächlich die Rückgabetypen von
Mutationen und die Abfragen zu definieren . Definieren Sie nun hier einen Typ und
nennen Sie ihn Earth Response. Und hier werden wir einen Benutzer haben. Und dann
wird dieser vom Typ Benutzer sein. Und wir werden
das in nur einer Sekunde definieren. Und hier benötigen wir auch das
JWT-Token vom Typ string. Zusätzlich zu all
diesen wird nun der eingegebene Benutzer
definiert. Wir müssen auch die ID
für den Benutzer definieren, denn wenn wir beginnen, die Datenbank zu
verwenden, werden
wir die ID zurückgeben. Ja, also müssen wir definieren,
dass sonst die ID nicht aus
dem GraphQL-Schema abgerufen
wird , wenn wir das Benutzerdokument
anfordern. Also der Ausweis hier. Und weil wir den Typ-Rep
verwenden, werden
wir Windeln
verwenden. Mit Postgres. Die ID wird vom Typ Nummer
sein. Aber in GraphQL können
wir keinen solchen
Zahlentyp verwenden, wir haben keinen, aber wir haben einen N-Typ. Ja. Und nur um sicherzustellen
, dass wir die ID jedes Mal erhalten, wenn
wir nach dem Benutzer fragen, fügen
wir hier ein
Ausrufezeichen hinzu. Und mit diesem Symbol können
wir ein erforderliches
Feld in unserem Schema definieren. Jetzt hat der Benutzer auch
all diese hier. Lassen Sie mich das kopieren
und hier einfügen. Und das war's. Verwenden wir nun
hier den Benutzertyp oder den
Antworttyp des Autors. Also hier, aus dem Gleichgewicht geraten
und dann sparen. Jetzt müssen wir sicherstellen,
dass die Anmeldeeingabe auch erforderlich ist, um zu verhindern, dass undefinierte Eingaben
erhalten. Und das Gleiche gilt für
die Reaktion der Erde. Ja, und jetzt
müssen wir unser Schema definieren. Und um das zu tun, werde
ich
das Schema-Schlüsselwort verwenden. Dann zitiere das. Wir werden die Mutation
definieren. Und es wird vom Typ Mutation sein
. Wenn wir dann die
Abfrage, die Abfragen, erstellen, können
wir hierher kommen und eine solche
Abfrage erstellen und
ihr dann den Abfragetyp geben. Aber im Moment haben wir nur eine
Mutation und stellen Sie sicher, dass Sie
zumindest hier
entweder eine Mutation
oder eine Anfrage oder beide haben . Andernfalls werden Sie das
GraphQL-Gateway nicht lösen. Lassen Sie uns das nun speichern und
einen Resolver erstellen , der
diese Anmeldelogik verarbeitet.
9. Auth erstellen: Nachdem wir unser
GraphQL-Schema definiert haben, erstellen
wir einen Resolver. Und weil wir
eine Anmeldemutation definiert haben , die sich auf die Authentifizierung
bezieht, werden
wir einen
Ordner im Quellordner erstellen. Und darin werden
wir eine Resolvers-Datei haben. Und hier definieren wir
das Objekt, das unsere Mutations
- und Abfragelogik
enthalten wird . Erstellen Sie also eine neue Konstante
und nennen Sie sie Resolver. Und es wird ein Objekt
mit einer Mutationseigenschaft sein. Und darin
definieren wir die Anmeldemethode. Und natürlich ist die
Anmeldemethode eine asynchrone Methode. Jetzt sind es
GraphQL-Resolver, die
ein übergeordnetes Argument und
ein Objekt haben ,
das den Eingabewert
sowie ein Argument oder ein
konstantes Kontextargument enthält das den Eingabewert
sowie . Wir werden
das Kontextargument erklären , wenn wir das Haupt- und das Modul
definieren. Aber im Moment wissen wir,
dass wir einen Input von unserem
Anmelderesolver
erhalten werden. Und alle Argumente in der Anmeldeeingabe
werden hier definiert. Für das übergeordnete Argument haben
wir
den Rückgabewert des übergeordneten Resolvers. Und das nur, wenn wir einen verschachtelten Resolver
haben. Aber in unserem Projekt werden wir das
nicht verwenden. Aber ich kann, ich kann dir ein Beispiel
zeigen. Stellen Sie sich also vor, wir
würden eine Anmeldemutation finden wollen, aber nicht auf diese Weise. Wir werden einen anderen
Typ erstellen und ihn benennen, melden Sie sich an. Und hier werden wir
gerne eine mit E-Mail haben. Und diese Methode gibt den Benutzersatz
zurück. Und wir werden uns auch, wie bei Google, bei Google
anmelden müssen. Und dieser gibt
ein Token vom Typ string zurück. Um dies zu verwenden, können
wir
hier auch die Eingabe
zur Breitenmethode hinzufügen und dann
diese Elternkrankheiten entfernen. Und hier
ist die Anmeldemutation , dass Sie vom Typ Anmeldung
sein werden. Und damit haben wir hier
einen verschachtelten Resolver innerhalb
der Autorenresolver definiert , wir müssen die
Anmeldemutation so definieren. Und wir werden nur
wie ein leeres Objekt zurückkehren. Und dann außerhalb des
Mutationsobjekts haben
wir
einen Anmeldetyp. Erstellen Sie also hier eine
Anmelde-Immobilie. Und darin definieren wir die Breite E-Mail
und verwenden Google-Methoden. Ja, also hier mit E-Mail und dann
wird es eine Methode sein. Natürlich ist es asynchron. Aber jetzt können wir die Eltern kriegen. Ja. Und in unserem
Fall, in diesem Beispiel, wird
das übergeordnete Objekt ein leeres Objekt
sein, aber auf diese Weise können wir
das verschachtelte Ergebnis
der Erstellung
verschachtelter Resolver und
der Verwendung des übergeordneten Arguments erhalten das verschachtelte Ergebnis
der Erstellung . Aber wie gesagt, wir wollten das
nicht benutzen,
weil es zu viel Töten ist. Meiner Meinung nach. Wir wollen nur einen einfachen Resolver. Lassen Sie uns alles wie
zuvor zurückgeben und
den Anmeldetyp entfernen. In Ordnung. Nun, in den Earth-Resolvern können
Sie hier sehen, dass wir
einen Typskriptfehler haben , der
besagt, dass all diese Argumente hier keine Typen
haben und das mit
TypeScript, wie Sie wissen,
nicht erlaubt ist. Im nächsten Video
lernen
wir, wie TypeScript-Typen automatisch aus
der GraphQL-Datei mit dem Schemapunkt
generiert werden.
10. Typescript aus einem Schema generieren: Um nun
automatisch typgestrickte
Typen aus unserem GraphQL-Schema zu generieren , müssen
wir
einige neue Pakete installieren. Gehen Sie also in Ihr Terminal
und führen Sie npm install dash aus, Großbuchstabe D für die Dev-Abhängigkeit. Und dann rechts der Bucket-Name, GraphQL, das ist
überzeugender Schrägstrich CLI. Und wir benötigen auch einige andere
Plug-ins für dieses Paket. Also nochmal, Co-Gen. Und wir
benötigen das TypeScript-Plug-in. Und auch hier wieder
GraphQL-TypeScript-Resolver mit Schrägstrich oder einem Strich. Und führe diesen Befehl aus. Und jetzt erstellen
wir in unserer
package.json-Datei hier
einen weiteren Befehl und nennen ihn generate. Und wir werden
das GraphQL-Coaching nutzen. Und dann spezifizieren wir
eine Konfigurationsdatei und nennen
sie Cogen Dot YAML. Natürlich
haben wir diese Datei noch nicht. Lassen Sie uns also
im Stammverzeichnis diese Konfigurationsdatei erstellen und
speichern. Wir werden
den Schemapfad angeben. In unserem Fall befindet es sich
im Stammverzeichnis, dann im Schema dot GraphQL und dann unter generiert. Wir werden
unsere generierten Typen
im Quellordner speichern . Und dann der von der Seite generierte Ordner. Und dann sagen wir, der Resolver
gibt eine Punkt-TXT-Datei ein. Und jetzt müssen wir die Plugins
spezifizieren. Also Plugins, wir haben
das TypeScript-Plugin installiert
und wir haben auch die TypeScript-Resolver installiert. Und jetzt müssen wir
einige Konfigurationen hinzufügen, die sich auf TypeScript
beziehen. Also würde ich die
Indexsignatur für true verwenden. Und diese Option hier ermöglicht es uns , dynamische
TypeScript-Typen zu generieren. Fügen Sie nun hier einen Doppelpunkt hinzu
und speichern Sie diese Datei und kehren Sie zur
Datei package.json zurück und speichern Sie sie ebenfalls. Dann lassen Sie uns diesen Befehl
vom Terminal npm aus
ausführen, generieren und darauf warten. Ordnung, wir haben
unsere Divs
erfolgreich innerhalb der
Resolver-Typen generiert . Sie können sehen, dass
wir die Antwort unseres Benutzers und unseres Autors hier in unseren Eingabetypen für die Mutationsanmeldung haben. Ja, der Benutzer ist hier und
alles ist deklariert. Natürlich gibt es viele Konfigurationen und andere
Typen, die mit Graph Girl zu tun haben. Ja, also schließen wir diese Datei jetzt und kehren zu den
Autoren-Resolvern zurück und importieren Resolver aus den generierten Resolvern. Schließen wir diese Datei
und gehen wir hierher zurück. Also verwenden sie alle drei Solver und verwenden diese aufgezählten
Typen, die wir Quelle oder aus
dem generierten Ordner
importieren müssen. Und aus der Datei mit den Resolver-Typen importieren
wir Resolver. Und
diesen Typ müssen wir hier implementieren. Und jetzt können wir sehen, dass alle
TypeScript-Fehler verschwunden sind. Denn jetzt weiß
TypeScript, dass die Mutationseigenschaft eine Anmeldemethode
hat. Bei der Anmeldemethode handelt es sich einen GraphQL-Resolver
und seinen Entwurf, Ihr Resolver hat ein übergeordnetes Element
mit einer Eingabe und einem Kontext. Und wenn Sie jetzt Eingaben schreiben, erhalten
Sie
Vorschläge für den Eingabetyp der Anmeldung. Lassen Sie uns nun mit
dem Aufbau der Anmeldemethode fortfahren. Und ich werde nur
zurückkehren und die Daten hier ablegen. Also müssen wir eine ID zurückgeben. Oder Sie müssen tatsächlich eine Benutzereigenschaft
zurückgeben. Und darin haben wir die Benutzer-ID und sie hat
die Typnummer. Fügen wir ID1 und die E-Mail hinzu. Dann fügen wir hier einfach
eine zufällige E-Mail und geben dann den
Vornamen und den Nachnamen zurück . Dies ist nur zum Testen,
da wir mit der Arbeit an den Haupt- und
Moduldateien
beginnen und unsere Ergebnisse
testen sollten Arbeit an den Haupt- und
Moduldateien
beginnen . Lassen Sie uns jetzt den Nachnamen
hinzufügen. Es wird
einfach benutzerfreundlich und sicher sein. Also müssen wir eigentlich die Eingabe hier
verwenden. Wir müssen
die Eingabe des
Benutzers, des Clients, zurückgeben . Also werde ich
alle Eigenschaften innerhalb
des Eingabearguments verteilen . Und Sie können sehen
, dass wir
keine Fehler von TypeScript haben . Das bedeutet also, dass wir dieselben Eigenschaften zurückgeben ,
die
existieren, um den Benutzer zu zitieren. Sie können also diese Seite sehen, den Schemapunkt GraphQL, wir haben E-Mail-Passwort, FirstName, LastName ist
der Benutzertyp und dasselbe in den Anmeldeeingaben. Deshalb
haben wir keine Fehler. Jetzt müssen wir noch das JWT-Token
zurückgeben. Und dieser wird nur eine zufällige Zeichenfolge
sein. Falls Sie es bemerkt
haben, haben wir keine Fehler erhalten, als uns das JWT-Token
fehlte. Ja. Und das liegt daran, dass der
Samstags-Schemapunkt GraphQL hier kein
Ausrufezeichen hinzugefügt wurde. Also müssen wir
dies hinzufügen oder diese beiden Eigenschaften als
erforderlich kennzeichnen und diese Datei speichern. Und jetzt müssen wir
den Befehl generate erneut ausführen, damit wir sicherstellen
können, dass
der Autor das Problem löst. Wir geben das
JWT-Token mit der Benutzereigenschaft zurück. Also hier haben wir das Schema
generiert, und los geht's, wir haben einen TypeScript-Fehler, der besagt
, dass uns die DWT fehlt. Wenn wir hier also
die DWT-Eigenschaft hinzufügen, wird
die Erde verschwinden. Und vorerst werden wir
nur ein paar Dummy-Daten schicken. Nachdem wir mit den
Haupt- und Moduldateien fertig sind, kehren wir hierher zurück und beenden alle
Mutationen und Abfragen. Und das liegt daran, dass wir immer noch eine Verbindung zu einer Datenbank herstellen
und die Benutzerentität
in dieser Datenbank erstellen
müssen . Nachdem das geklärt ist, werden
wir
im nächsten Video mit der Arbeit
am Modul und
den Hauptdateien beginnen .
11. Richte unseren Apollo-express ein: Jetzt richten
wir innerhalb des
Moduls, der ts-Datei, unseren Apollo-Server so ein, dass er
mit unserem GraphQL-Schema arbeitet. Und der Autor ist Solvers. Beginnen wir also mit dem
Import einiger Pakete. erste ist der Apollo-Server von Apollo Server Express und Import Express
von Package Express. Und wir benötigen auch das
HTTP-Paket vom HTTP-Paket. Und Sie müssen es nicht
installieren, da wir es standardmäßig mit NodeJS
haben. In Ordnung, jetzt exportieren
und erstellen wir eine neue Klasse
und nennen sie App-Modul. In dieser Klasse werden
wir
einen Konstruktor haben , der Resolver
akzeptiert. Erstellen Sie hier also eine öffentliche
Variable und nennen Sie sie Resolver, und es wird
vom Typ Resolver sein. Wir müssen das aus
dem generierten Ordner und aus
der Resolver-Typdatei importieren . Und hier bekommen wir eine
Fehlermeldung, weil wir Resolver
importieren und verwenden müssen, nicht Resolver. Also füge dort ein S hinzu. Und hier werden wir
eine Methode erstellen , die
den Apollo-Server initiiert. Also Apollo mit Eiscreme starten. Und diese Methode sollte zurückkehren. Natürlich ist es ein Versprechen, und das Versprechen sollte
ein Objekt mit einem HTTP-Server, einer
Eigenschaft des Typs HTTP-Server, lösen ein Objekt mit einem HTTP-Server, . Und wir müssen einen Server
oder eine Eigenschaft vom Typ
Apollo-Server zurückgeben . Erstellen wir nun eine Konstante
und nennen sie Server
und verwenden die Apollo-Serverklasse, und verwenden die Apollo-Serverklasse um eine neue
Apollo-Serverinstanz
mit einigen Konfigurationen zu erstellen . Hier müssen wir also unser
GraphQL-Schema und die Resolver übergeben. Und ich werde mit Resolvern
beginnen und
diese Variable hier übergeben. Und natürlich
befinden wir uns in einer Klasse, also müssen wir das
Schlüsselwort this und dann die Ergebnisse verwenden. Für das Schema haben
wir nun den Typ
Deaths-Eigenschaft. Und wir müssen diese Datei,
den Schemapunkt GraphQL, nehmen den Schemapunkt GraphQL, und sie hier übergeben. Und dafür verwenden wir
die Methode zum Synchronisieren von Dateien
aus unseren From Alpha-Paketen. Also hier Read File Sync
und aus fs importiert. Und davor, dem Server, werden
wir eine Konstante für
Typ-Todesfälle erstellen. Und hier verwenden wir den Read File Sync um das GraphQL-Schema
aus dem Schema
dieser GraphQL-Datei zu lesen . Also lass mich das löschen. Und hier, lass uns weitermachen. Wir müssen den Pfad angeben. Und weil wir diese schematische GraphQL-Datei
im Stammverzeichnis
haben, können wir sie so schreiben. Schemadiagramm Mädchen. Und wir werden diese Datei mit der
Kodierung auf UTF 8 lesen . Denn ohne die
Kodierungsoption bekommen
wir einen Puffer
zurück. Aber hier brauchen wir eine Schnur. Also entferne den Doppelpunkt und gib
einfach den Typ
Todesfälle wie diesen an. Jetzt müssen wir den Server starten, also warten Sie auf den Server, der gestartet wird. Und dann müssen wir die Apply Middleware erstellen
oder verwenden. Und hier
fügen wir eine Express-Medulla hinzu. Lassen Sie uns also zuerst
eine App mit Express erstellen und sie hier als Mittelalter
verwenden. Ok, jetzt müssen wir einen HTTP-Server
zurückgeben. Aber die App hier ist
nicht vom Typ HTTP. Dieser Server
ist vom Typ Express. Also werden wir
die HTTP-Pakete verwenden , um mithilfe der App-Anwendung,
ich meine die Express-Anwendung, einen HTTP-Server zu
erstellen . Erstellen Sie hier also eine neue Konstante
und nennen Sie sie HTTP-Server und verwenden Sie dann http dot, create server und
übergeben Sie sie dort. Dann hier, das hat
den HTTP-Server mit
dem Apollo-Server zurückgegeben . Jetzt müssen wir eine neue Instanz
initiieren und aus
der Moduldatei exportieren. Exportieren Sie hier also
Constant Up Audio und erstellen Sie dann eine neue
App-Modulinstanz. Hier müssen wir die Ergebnisse
weitergeben. Also müssen wir zuerst importieren,
der Autor ist vorbei. Also hier importieren wir unsere Resolver, und ich denke, wir haben sie nicht aus der Ogres-Datei des
Autors
exportiert. Also lass uns das hier machen. Exportieren, exportieren. Der Autor ist Solvers. Und dann lassen Sie mich das kopieren, zu einem Modul zurückkehren und die Autorenresolver
von go out oder
innerhalb des Earth-Ordners und
innerhalb der Autorenergebnisse
importieren von go out oder . Gehen wir jetzt hierher zurück und
verwenden die Resolver hier und speichern dann diese Datei. Und im nächsten Video werden
wir anfangen, in der Datei main.js zu arbeiten.
12. Unsere API ausführen und testen: In der Datei main.js müssen
wir
das Modul aus
der Moduldatei importieren und dann eine Bootstrap-Funktion
erstellen. Und es wird asynchron sein. Und hier werden wir den HTTP-Server und den Server aus
dem Modul
extrahieren , das eine Bottle-Methode startet. Und dann verwenden wir
den HTTP-Server, um
Verbindungen zu initiieren oder abzuhören initiieren oder abzuhören, die
beide für Tausende verfügbar sind. Dann senden wir eine Nachricht
an die Konsole zurück, die besagt, dass Server unter
http localhost bereit ist. Und dann der Port 4.000. Und hier müssen wir
den Pfad des GraphQL-Gateways
vom Apollo-Server abrufen . Also werde ich
hier eine weitere Zeichenfolge
vom Server anhängen , diese GraphQL-Pfadeigenschaft. Und dann bekommen wir den
Pfad für das GraphQL-Gateway. Okay, jetzt müssen wir noch Bootstrap-Funktion
ausführen, die Bootstrap-Funktion bezeichnet wird. Und jetzt speichern wir die Datei
main.js und gehen zur Datei
package.json und fügen
einige Skripte hinzu, um unsere App auszuführen. Also hier, erstelle einen neuen
Startbefehl und wir müssen
unseren Code kompilieren und dann die Datei main.js
ausführen. Und dieses Mal verwenden
wir die Option dash, dash what ohne Ts, anstatt
Node-Manpakete zu verwenden. Und um diese Option verwenden zu
können, benötigen Sie die
neueste Version der Notizen. Ja. Also ich habe die Version
19 sollte mindestens 18 haben. Stellen Sie also sicher, dass
Sie Ihre Version von Node.JS aktualisieren. Dann hier der Pfad
zur Datei main.js. Also dieser Ordner, dann der Quellordner und
dann die Hauptpunkt-JS-Datei. Und jetzt nehmen wir den TSO-Befehl hier und fügen
ihn in einen anderen Befehl ein. Erstellen Sie hier also einen
Kompilierungsbefehl und fügen Sie den TSC dort ein. Dann werden wir hier npm
ausführen, compile ausführen. Also werden wir unseren Code kompilieren
und dann die Datei main.js ausführen und nach Updates
oder nach Änderungen suchen. Speichern wir nun die Datei
package.json und die Clubs. Und hier im Terminal lassen Sie uns npm ausführen, starten. Und wir haben einen Fehler. Und das liegt daran, dass wir unserem Schema eine Abfrage
hinzufügen müssen. Im Moment verwenden wir also
keine Abfragen, aber ich werde eine
sehr einfache Abfrage hinzufügen. Also hier, unter Mutation, werde ich darin eine
neue Typabfrage ausführen oder erstellen.
Ich erstelle eine Abfrage, die eine Zeichenfolge zurückgibt. Und hier
definiert das Schema eine Abfrage. Und dann hier auch
abfragen und speichern. Und dieses Mal
müssen wir
die Typen neu generieren und dafür
einen Resolver erstellen. Also npm run, generate. Und dann in den Resolvern des
Autors. Lassen Sie uns
hier eine Abfrage erstellen und die Methode abrufen. Es sollte also eine Immobilie sein
und sie dann zitieren. Wir werden die
get-Methode haben und nur eine Zeichenfolge zurückgeben. Also werde ich
eine LK-Zeichenfolge zurücksenden und dann die
Anwendung
speichern und erneut ausführen. Hier, npm, run, start. Ordnung, jetzt
haben wir unseren Server bei localhost 34.000 Slash GraphQL. Und hier
haben wir anscheinend einen Schrägstrich hinzugefügt, aber das werden wir später korrigieren. Gehen wir nun zu unserem Browser und navigieren
zu localhost 4.000 GraphQL und klicken Sie auf Query your server, damit
wir Zugriff auf erhalten können. Fotostudio. Und von hier aus werden wir unsere Mutationen und Abfragen
testen. Ordnung, jetzt sind wir in der Apollo-Sandbox und unter root finden Sie hier die
Abfrage und die Mutation. Jetzt beginnen wir mit dem Entstauben der Mutation und
versuchen, uns anzumelden. Natürlich haben wir Dummy-Daten, aber wir werden hier nur das
GraphQL-Gateway testen. Um die Anmeldeabfrage hinzuzufügen, klicken Sie auf das Plus-Symbol und Sie erhalten die Mutation und dann die Anmeldung mit der Eingabe. Und so definieren wir
unsere Mutation vom Licht, vom Frontend
oder vom Kunden aus. Also hier ist die Eingabe hier eine Variable und sie ist vom
Typ Sign-up input. Also haben wir diesen Typ natürlich
aus dem Schema. Und hier
definieren wir die Anmeldemutation
oder die Anmeldemethode. Ja, das ist also nur die
Art der Mutation, und das ist die eigentliche Mutation. Und wir fügen
das Eingabeargument hinzu oder setzen es so, dass es der Variablen
entspricht. Und wir können, ah, die
Eingabevariable von hier aus
bearbeiten. Wie Sie hier sehen können,
befinden wir uns im
Variablenbereich und hier können wir alle
erforderlichen Variablen
definieren. In der Anmeldemethode definieren
wir nun auch den Rückgabetyp und das schematische GraphQL für den
Samstag. Sie können sehen, dass die
Anmeldemutation
eine Antwort zurückgibt und der andere Ehepartner ein Benutzerfeld mit
dem JWT-Feld hat. Hier können wir also angeben, welche
Immobilie wir bekommen werden. In unserem Fall bekommen
wir also den Benutzer und nur interessant und die ID. Und dann bekommen wir x, oder wir warten auf
die DWT. Und das war's. Das ist das Coole
an GraphQL. Ermöglicht es Ihnen zu entscheiden , welche Daten Sie als Antwort erhalten möchten
. Anstatt also
das gesamte Benutzerdokument
mit dem E-Mail-Passwort,
Vorname und Nachname, zurückzugeben das gesamte Benutzerdokument , können
wir Draft Girl
anweisen, nur
die ID und
natürlich auch das JWT-Token zurückzuschicken die ID und
natürlich auch das JWT-Token , da wir es zur
Authentifizierung des Benutzers verwenden
werden. Lassen Sie uns nun diese Abfrage ausführen indem Sie hier auf die Schaltfläche
Anmelden klicken. Und natürlich haben wir vergessen
, die Eingabe hinzuzufügen. Diese Anfrage wird also fehlschlagen. Sagt, dass die Variableneingabe nicht Null
ist und nicht Null sein darf. Also hier, lasst uns das ändern. Und statt der Argumente
hier, Abschnitt Argumente, finden
wir die Eingabe vom
Typ Sign-up input und Sie können hier die erforderlichen
Typen hinzufügen. Lassen Sie mich das alles
in E-Mail,
Passwort und
Vorname, Nachname löschen . Sie alle sind erforderlich. Wählen Sie nun für die E-Mail
nur den Benutzer auf email.com aus, und für das Passwort werden nur Passwort,
Vorname, Benutzer eins und der Nachname des
letzten Jahres, Benutzer, gesendet . Lassen Sie uns nun
erneut diese Anfrage oder
diese Mutation senden und auf die Antwort
warten. Ordnung, wir haben die ID von einem und das JWT-Token
als diese Zeichenfolge hier. Und Sie können überprüfen, ob diese
Zeichenfolge dieselbe Zeichenfolge ist, die wir in der
Return-Anweisung hier
definiert haben . Also das JWT oder Eigentum. Wir haben also unser GraphQL-Gateway mit Express
- und Apollo-Servern
arbeitet. Und lassen Sie uns ganz schnell
auch die Abfrage testen. Ja, also werden
wir die get-Methode ausführen, stellen sicher
, dass wir sie einfach
dort belassen und die Abfrage get hinzufügen. Also füge das hier
in der getMethod hinzu. Und für diese Abfrage erwarten
wir keine Eingaben. Deshalb können wir die get-Methode einfach so ohne Klammern
schreiben, n ohne Argumente, dann die Abfrage ausführen und
wir sollten, okay, String bekommen. In Ordnung, wir haben das hier. Und jetzt wissen wir, dass all
unsere Abfragen und
Mutationen funktionieren und dass wir unsere Resolver ausführen
können. Jetzt müssen wir die Arbeit an
der Anmeldemutation
beenden und auch alle Resolver hier
fertigstellen. Vorher müssen wir jedoch
type around verwenden, um eine
Benutzerentität zu erstellen, damit wir einen Benutzer erstellen und in der Datenbank
speichern
können.
13. Typeorm installieren und konfigurieren: In diesem Projekt werden
wir
Type Round verwenden , um
unsere Datenbank zu verwalten. Es gibt viele
Organismen, aber der beliebteste ist
der Typ Rampe. Und das liegt daran, dass es viele Funktionen
hat und einfach zu bedienen ist,
insbesondere mit TypeScript. Jetzt ist ein OR ein Object
Relational Mapper. Sie können hier auf diesen
Link klicken und er führt Sie zu
einer Wikipedia-Seite. Und Sie können hier mehr
über Object Relational
Mapping lesen . Ja. Aber TypeScript oder unser Type Ramp
steht zusammen für TypeScript, object relational,
mapper und type around. Es ist eine Bibliothek, die es einfach
macht,
unsere TypeScript-Anwendungen
mit einer relationalen Datenbank zu verknüpfen . Und in unserem Fall werden
wir Postgres
als unsere relationale Datenbank verwenden. Und natürlich
unterstützt Diaper Amps viele
andere Datenbanken, sogar MongoDB, aber es befindet sich noch
im experimentellen Stadium. Wenn Sie also
MongoDB verwenden möchten, können Sie das tun, aber Sie müssen
viele andere Setups hinzufügen. Denn wie Sie wissen, wir
bei der Verwendung von Mongoose einige Schwierigkeiten, hatten wir
bei der Verwendung von Mongoose einige Schwierigkeiten,
als wir TypeScript
mit Mongoose-Modals implementieren wollten . Ja, also das Gleiche
passiert hier mit Diaper M, aber wir haben viele andere
Optionen wie Postgres, C-Corps und mein SQL oder Sequel Light und alle anderen Datenbanken. Jetzt können Sie zum Typ
Parametertitel navigieren und
mehr über seine Funktionen erfahren. Aber in diesem Projekt werde
ich Ihnen natürlich beibringen, wie man den Typ Rahm installiert, wie man ihn benutzt, wie
man eine Entität erstellt, welchen Typ um und
vieles andere. Öffnen wir also unseren VS-Code. Und im Terminal beginnen
wir mit der Installation von Type Around und dem Postgres-Treiber. Außerdem benötigen wir ein anderes
Paket mit dem Namen Reflect Meta data, weil
wir entweder tippen oder M die Zeichen
verwendet. Und um die Zeichen
mit TypeScript zu verwenden, müssen
wir das
Reflect Me The Data hier installieren. Also das sind ich, diese Daten. Andernfalls bekommen wir, dass
wir unsere Anwendung nicht
ausführen können. Stellen Sie also sicher, dass Sie das installieren. Und auch wenn Sie die Typen zur Notiz nicht
installiert haben, stellen Sie sicher, dass Sie dies tun. Ja,
das habe ich vom ersten Video aus installiert. Also werde ich
diesen Befehl ausführen und auf die Installation
warten. Ordnung, jetzt müssen
wir in
der Datei main.js die
Reflect-Metadaten Beckett importieren ,
um die Zeichen verwenden zu können. Also lass mich das kopieren. Und der Grund, warum
Sie sich für main.js entscheiden
, ist , dass es unsere
Hauptdatei für dieses Projekt ist. Also werde ich
alles aus dem Import importieren. Sie spiegeln mir wider, dass
Theta hier Klammern. Und wir müssen hier einige
Konfigurationen hinzufügen. Und so die TS-Konfiguration
, die Spaß macht. Also müssen wir
zwei weitere Eigenschaften hinzufügen. erste ist der Emit, die Zeichen
und Metadaten und wird auf true gesetzt. Und auch die experimentellen
Dekorateure machten sich auf den Weg. Und diese Eigenschaften sind
sehr wichtig, wenn wir
die Zeichen
in unserer Anwendung ausführen oder verwenden möchten . Wenn Sie jetzt nicht wissen, was,
was die Charaktere sind, werden
wir etwas über sie erfahren, wenn wir mit der Erstellung unserer Entitäten beginnen.
14. user erstellen: Nun, da wir den Typ
ramp in unserem Projekt haben, beginnen
wir mit der Erstellung
der Benutzerentität. also innerhalb des Ordners Erstellen Sie also innerhalb des Ordners einen anderen Ordner und
nennen Sie ihn hier die Benutzerseite Erstellen Sie einen weiteren
Ordner mit dem Namen Entität. Und dann
erstellen Sie
im Entitätsordner den Benutzer, diese
Entität, die TS-Datei. Nun werden wir die
Zeichenentität aus Type Wrap
importieren. Und dann exportieren wir
einen Klassennamen, einen Teaser. Und hier
verwenden wir die Decorator-Entität. Und so definieren wir
Entitäten mit Windel m. Jetzt sind die Zeichen
nur einfache Funktionen. Ja, das gibt
eine andere Funktion zurück, verwendet
aber auch sehr
spezifische Argumente und sie müssen mir
das Datenpaket widerspiegeln, um zu funktionieren. Ja, wenn Sie also einen Dekorateur erstellen
möchten, können
Sie online suchen, aber ich gebe Ihnen ein
sehr einfaches Beispiel. Stellen Sie sich vor, wir haben hier eine Entität. Stellen Sie sich vor, wir wollten
eine Entität erschaffen , den Charakter. Also werde ich es tun, ich werde eine Konstante erstellen
und ihr Entität nennen. Und dann
erstelle ich eine Funktion. Und diese Funktion muss eine andere Funktion
zurückgeben. Jetzt sollte die zweite Funktion
hier ein Ziel und
einen Eigenschaftsschlüssel akzeptieren. Denn Tiki kann vom Typ String und auch ein
sogenannter Distributor sein. Dieser Griff da. Und dieser ist vom Typ
Eigenschaftsdeskriptor. Natürlich sollten wir den
Funktionsverteiler nicht für eine Klasse
verwenden. Deshalb haben wir hier
einen Fehler. Ja, aber Sie können in der Dokumentation mehr über
die Vertriebspartner
erfahren . Per TypeScript können Sie hier
mehr über die Charaktere lesen. Also kopiere diesen Link und du kannst hier einiges
über Klassenverteiler
wissen, z.B. hier, wie wir sie hier bauen. Also hier erstellen wir eine Funktion
mit einem Konstruktor. Der Konstruktor ist
nur eine Funktion. Und dann verwenden wir hier viele
JavaScript-Methoden, um die Eigenschaften
und Methoden aus
der Klasse zu
handhaben oder zu extrahieren und Methoden aus und
etwas damit zu tun. Ja, jetzt, wenn du
mehr über sie lesen willst, komm
unbedingt her und
versuche z.B. , deine eigenen Werkzeuge
oder deine eigenen Dekorateure zu bauen. Ja, aber
lassen Sie uns das vorerst entfernen und
mit unserer Benutzerentität fortfahren. Jetzt benötigen wir einen Vornamen
in unserer Benutzerentität. Also hier, schreibe den Vornamen. Und dieser wird
vom Typ String sein. Und stellen Sie sicher, dass es sich um eine
TypeScript-Zeichenfolge handelt. Ich meine, mit einem Kleinbuchstaben als. Und wir müssen hier
einen anderen Charakter verwenden. Und dieses Zeichen
wird Spalte genannt. Also spalte von type
around und verwende es hier. Spalte. Jetzt haben wir den FirstName, den LastName, den
Nachnamen vom Typ string. Und natürlich werde ich die Spalte wieder
benutzen. Und wir benötigen auch
die E-Mail vom Typ string. Und dann die Kolumne.
Und das Coole am Typ, wo m ist, auch wenn Sie eine MongoDB
oder eine andere Datenbank verwendet haben, können
Sie definieren,
Sie müssen
die Entitäten immer in
derselben Form mit derselben Struktur definieren . Außer Mongoose. Denn wie ich bereits sagte, es befindet sich noch im
Versuchsstadium. Ja. Und es war
lange da, aber du kannst immer noch damit arbeiten, aber du musst ein Schema erstellen. Wir können
mit Mongoose mit Windel keine Entität gründen. Lassen Sie uns nun
mit der Benutzerentität fortfahren. Wir benötigen immer noch das Passwort, und es ist immer der
Typ string hier. Und ich werde eine
Konfiguration für das Passwort hinzufügen. Und um das zu tun, können wir hier ein Objekt
übergeben und sagen, oder eine Eigenschaft, auswählen und auf false setzen. Und das bedeutet, dass wir nicht
wollen , dass das Passwort nicht an den Client zurückgegeben wird. Ja, wir wollen
das Passwort verstecken und
so machen wir das mit Type. Jetzt können wir viele
Konfigurationen hinzufügen, z. B. für die E-Mail hier, das können wir. Ich habe erwähnt, dass wir nicht
wollen, dass das Bild nicht ist. Also verwenden wir die
Eigenschaft nullable und setzen sie auf false. Die E-Mail wird also nicht sein, Nein. Das ist wie eine Validierung
mit Windel N, aber wir werden
eine andere Methode für die Validierung verwenden , eine
fortgeschrittenere Methode. Ja. Jetzt
brauchen wir immer noch, immer noch den Ausweis hier. Da die Idee jedoch
automatisch
von Posterioren generiert wird , verwenden
wir einen anderen
Decorator, um die ID zu definieren und dafür zu sorgen, dass das Zeichen als
primär generierte Spalte bezeichnet wird. Und hier werden wir diesen Dekorateur
benutzen. Die primäre Spalte ist also die generierte Spalte. Und hier definieren wir die ID. Und wie ich für PostgreSQL sagte, wir werden
Ideennummern bekommen. Speichern wir nun dieses
und das nächste Video.
Wir erstellen den Benutzerdienst und
beginnen, die
Benutzerentität zu verwenden. Also wir sehen uns dort.
15. Create-user | user.service: wir nun im Benutzerordner Erstellen
wir nun im Benutzerordner eine weitere Datei und
nennen sie User Service Tiers. Und hier exportieren und
erstellen wir den Klassenbenutzerdienst. Und dann
füge ich einen Konstruktor hinzu. Und darin definieren
wir eine öffentliche Variable und
nennen sie Benutzer-Repository. Und es wird vom Typ
Repository sein. Und wir werden
die Repository-Schnittstelle
von Schreibmaschinen importieren , also weiter, das Repository
vom Typ Ramp. Und hier im Repository. Und wir müssen
die Entität hier übergeben. Wenn du mit der Maus darüber fährst, wirst
du feststellen, dass es
erforderlich ist , um
es in unserer Klasse verwenden zu können. Also fügen wir hier
die Benutzerentität hinzu und müssen sie aus
der Dateibenutzerentität importieren. also für jeden Benutzer aus der Benutzerentität oder
innerhalb der Entitätsdatei Verwenden Sie also für jeden Benutzer aus
der Benutzerentität oder
innerhalb der Entitätsdatei oder diese Entität. Jetzt können wir damit beginnen, die erste Methode zu
erstellen, die Methode create, mit der wir einen neuen Benutzer erstellen. Also Async create. Und dann hier
für die Argumente, es
wird eine Anmeldeeingabe sein. Und wir werden auch hier
die automatisch
generierten Typen verwenden . Der Typ für
dieselbe Eingabe hier. Lassen Sie uns also das
Anmeldeeingabeargument der Anmeldeeingabe
, der Schnittstelle und dem Typ zuweisen . Und wir werden das
von einer Ebene nach außen
und dann von zwei Ebenen importieren . Und Site
Generated wählt den Resolver-Typ und
die Anmeldeeingabe aus. Und wenn Sie mit der Maus über
die Anmeldeeingabe
fahren, finden Sie hier alle
erforderlichen Eigenschaften, wie den Vor- und
Nachnamen der E-Mail-Adresse sowie das Passwort. Natürlich, ohne
die ID, weil er es ist,
wird es automatisch generiert. Und hier repariere den Async. Als Erstes
müssen wir innerhalb der Create-Methode das
Passwort hashen. Dafür benötigen wir das
andere Paket. Also lasst uns das Terminal öffnen. Und ich werde den
Beckett Names Decrypt abstellen. Und wir würden es verwenden, um unser Passwort
weiterzugeben und auch die Passwörter zu vergleichen ,
wenn wir den Benutzer
anmelden möchten. Also hier installiert npm die Krypta. Und wir müssen auch
die Typen für installieren, sei korrekt. Führen Sie dann diesen Befehl aus. Warte auf die Installation
und das war's. Lass mich das löschen und das Terminal
schließen. Und hier, lass mich den
Big-Rip-Kurs in der Krypta abbrechen. Und hier werden wir neue Passwörter
erstellen,
ein Hash-Passwort. Warte auf die Verschlüsselung. Dieser Hash. Und hier geben wir
die Anmeldeeingabe weiter. Also melde dich hier an. Geben Sie das Passwort ein. Und dann müssen wir uns für eine Salzrunde
entscheiden. Also hier wähle ich
zehn als Salt-Runden. Und hier erhalten wir eine
Fehlermeldung, weil das Passwort, wenn Sie den Mauszeiger darüber bewegen, werden
Sie feststellen, dass alle
Eigenschaften innerhalb des
Anmeldeeingabetyps nicht erforderlich sind. Um das zu ändern. Wir müssen
zu dem Schema von GraphQL gehen. Und außerdem füge hier ein Ausrufezeichen für
alle Eigenschaften hinzu. Und lassen Sie uns
dasselbe für den Benutzer tun. Das brauchen wir also nur
für das Passwort. Ja. Weil wir es nicht
zurückschicken wollten. Und dann geht es unter. Speichern
wir das. Und wir müssen das Terminal öffnen
und die Typen generieren. Also hier, npm run, generate. Und das war's. Lassen Sie mich das löschen oder schließen
Sie einfach das Terminal. Gehen Sie zurück zum Benutzerservice und der Fehler ist verschwunden. Und jetzt ist das Passwort vom
Typ string, bevor es vielleicht vom
Typ war , oder so
ähnlich. Sie werden hier eine andere Schnittstelle
oder eine Klasse verwenden , um
nicht benötigte Eigenschaften zu definieren. Aber wenn es erforderlich ist, verwenden
wir hier diesen Typ, aber er ist automatisch, degeneriert. Das ist uns egal. Lassen Sie uns nun mit der
Erstellung des Benutzers fortfahren. Erstellen Sie nun eine Benutzerkonstante, verwenden Sie
dann dieses
Punkt-Benutzer-Repository und erstellen Sie
dann eine Methode aus
dem Benutzer-Repository. Und hier verteilen wir den Benutzer oder
die
Anmeldeeingabe, die Anmeldeeingabe. Und dann
fügen wir das Passwort hier hinzu. Ich weiß also, dass wir in der Anmeldeeingabe bereits ein Passwort
haben, aber wenn wir
die älteren Eigenschaften wie diese
in einem Objekt verteilen und dann weitere Eigenschaft mit
demselben Namen
hinzufügen , die
in der Anmeldeeingabe existiert. Wir werden diese Immobilie tatsächlich
aktualisieren. Und wir werden
das Passwort hier auf das Passwort hier auf diesen Wert für das
HashSet-Passwort setzen lassen. Lassen Sie mich jetzt, wir
müssen den Benutzer speichern. Und dazu müssen wir
diese
Punktspeichermethode für das Benutzer-Repository verwenden diese
Punktspeichermethode für das Benutzer-Repository und das neu
erstellte Benutzerdokument übergeben. Natürlich werden wir
dieses Dokument an den Kunden zurücksenden . Also hat es das zurückgegeben
und warte darauf. Und dann speichern. Nun, um
den Benutzerdienst in
den Earth Resolvern zu nutzen. Und weil der Autor ein
Solver ist, also ein Objekt ist, können
wir keine öffentliche Variable hinzufügen und sie auf den Benutzerdiensttyp des
Benutzers setzen. Wir müssen also
eine Instanz aus
dem Benutzerdienst erstellen und sie
exportieren, damit wir sie
in den Autorenergebnissen verwenden können. Ja, also, richtig, exportieren, dann konstanter Benutzerdienst und ich werde eine neue
Instanz des Benutzerdienstes hinzufügen. Und hier müssen wir
das Benutzer-Repository übergeben. Und dafür müssen wir die Datenquelle
erstellen. Und aus der Datenquelle holen
wir uns
das Benutzer-Repository. Das werden wir im
nächsten Video machen.
16. app hinzufügen: Lassen Sie uns nun
die App-Datenquelle erstellen und dann hierher zurückkehren. Sie also im Quellordner Erstellen Sie also im Quellordner eine neue Datei und benennen Sie sie, Datenquelle, das Ts. Und hier müssen wir
die
Datenquellenklasse aus der Windel importieren . Und hier müssen wir eine Konstante
exportieren, sie als Datenquelle
benennen. Und es wird
einer neuen Instanz der
Datenquellenklasse entsprechen . Und hier haben wir
den Typ der Datenbank. Und in unserem Fall werden
wir die
Postgres-Datenbank verwenden. Sie können hier sehen, dass wir viele Datenbanken
haben, wie ich schon sagte, haben meine Krankheit oder haben viele andere Datenbanken
wie MongoDB hier. Also werden
wir für uns Postgres verwenden. Und Sie müssen
Postgres in diesem Projekt wählen denn danach
werden
wir Docker verwenden, um die
Postgres-Datenbank in
unserem lokalen System auszuführen . Ja. Wenn Sie also an diesem
Kurs teilnehmen möchten, müssen
Sie sich auch
für Postgres entscheiden. Jetzt benötigen wir den Host für
die Datenbank und in unserem Fall werden
wir die
Datenbank auf dem lokalen Host ausführen. Und wir werden den Hafen
wählen. Und für Postgres
haben wir den Port 5432 und wir benötigen einen Benutzernamen
für die Datenbank. All diese Informationen
würden ebenfalls hinzugefügt und verwendet, wenn wir unsere
Postgres-Datenbank mit Docker
initiieren. Also hier der Benutzername, der Admin wählen
wird. Und für das Passwort wähle
ich auch admin. Und dann der Datenbankname, es wird die Hauptdatenbank sein. Und jetzt müssen wir unsere Entitäten
definieren. Die Entitäten. Es ist ein Array ,
das alle Entitätsdateien enthält. Sie können also den
Pfad der Entität angeben. Aber es gibt einen besseren Weg, dies
zu tun, indem
wir zuerst den
Ordner dist abgewählt haben und dann zwei Sterne
hinzufügen um einen beliebigen Ordner auszuwählen oder in einem Ordner zu
suchen. Und dann füge hier einen Stern hinzu, dann das Punktelement, das G hat. Mithilfe dieses Pfads wählen
wir nun wählen
wir alle Dateien im Ordner
dist und in
jedem Ordner aus, der in diesem
Ordner existiert und am
Ende seines Namens
eine Punkt-Entität hat . Ja. Jetzt brauche ich noch mehr
Eigenschaften wie die Protokollierung. Wir wollen keine Sequel-Abfragen
in unserem Terminal erhalten . Für die Protokollierung wähle
ich also Falsch. Und wir müssen hier die
Synchronisierungsoption hinzufügen. Stellen Sie jedoch sicher, dass Sie es nur
für die Entwicklung unserer
Datenbank oder unseres Projekts auf wahr
setzen . Und Sie können hier die
Dokumentation dieser Immobilie lesen. Und das ist eine
Warnung, dass Sie verlieren werden, wenn Sie die Option und den Produktionsmodus
verwenden, die Option und den Produktionsmodus
verwenden,
genauso wie
Sie Produktionsdaten verwenden würden. Also im Grunde diese Option hier, wir werden die Datenbank aktualisieren. Und weil wir Postgres
verwenden, ist
es eine relationale Datenbank. Es wird, im Folgenden
werden
die Datenbanktabellen
zwischen allen Entitäten aktualisiert . Dies ist jedoch kein sicherer
Weg, um das Schema zu aktualisieren. Daher werden wir es nur verwenden. Verwenden Sie diese Option hier. Dann werden wir damit arbeiten, wir werden Patienten herstellen hinzufügen und wir werden diese
Option hier streichen. Lassen wir es vorerst auf
true setzen und
zum Benutzerservice zurückkehren. Und wir müssen
die Datenquelle importieren, die
Datenquelle von einer Ebene aus, zwei Ebenen als das Update. Es ist also da und wir
werden es hier verwenden. Datenquelle, dann
Punkt Git-Repository. Und wir müssen das Ziel hinzufügen. Und das Ziel ist
ein Entitätstyp. Also müssen wir
hier
die Benutzerentität übergeben , damit wir
das Benutzer-Repository abrufen können. Im nächsten Video werden
wir jetzt anfangen, mit dem Autor ist Solvers zu arbeiten. Und wir werden
diese Anmeldung beenden oder noch nicht abgeschlossen sein, aber fangen wir an, an
dieser Anmeldemethode zu arbeiten .
Also wir sehen uns dort.
17. signup erstellen: nun in der Anmeldemutation Lassen Sie uns nun in der Anmeldemutation diesen Code hier entfernen. Und als erstes müssen
wir einen neuen Benutzer erstellen. Also ständiger Benutzer als auf den Benutzerservice
warten. Und das kann er sich leisten,
wenn Benutzer den Benutzerservice einschränken. Und dann verwenden wir
die Methode create und übergeben die Eingabe oder
die Anmeldeeingabe. Und für uns ist es hier nur
das Eingabeargument. Der Rückgabetyp
der Anmeldemutation ist nun Objekt, das ein
Benutzerfeld mit dem JWT-Feld hat. Also müssen wir ein JWT-Token
erstellen. Und dafür
öffnen wir unser Terminal und installieren npm JSON Web Token. Und natürlich brauchen wir die Typen, Typen JSON Web Token. Und lass mich das klären,
schließ das Terminal. Und hier müssen wir
ein JWT-Token mit
dem JWT-Paket generieren . Importiert JWT aus dem JSON-Webtoken. Sie wissen, wie
das geht, wir müssen
JWT als die Anmeldemethode verwenden . Hier. Wir geben die Nutzlast weiter. Und dieses Mal
füge ich eine Payload mit E-Mail aus der Eingabe, dieser E-Mail und einer
Benutzer-ID aus der Benutzer-ID hinzu. Und wir brauchen ein JWT-Token. Also müssen wir eine Datei mit
Punktlänge erstellen und dort die
JWT-Tokenvariable hinzufügen. also
auf der Router-Ebene unseres Projekts Lassen Sie uns also
auf der Router-Ebene unseres Projekts eine Datei erstellen. Und hier ein JWT-Schlüssel und füge einige zufällige Zeichen hinzu. Und dann speichern. Dann benötigen wir das
Paket, das die Dateien in
einem TypeScript-Projekt für uns
liest. Und das sind die Klammern. Also npm install dot. Dann ist das, das ist
sicher. Dev nicht speichern. Lass mich das jetzt klären. Schließen Sie das Terminal und
wir verwenden
den Punkt m, der
in die Datei main.js aufgenommen wird. Also hier importiere ich
alles wie in. Von hier aus werden
wir diese Methode in der Gotik verwenden
und nennen. Und stellen Sie sicher,
dass Sie dies
hier oben für alle
Importanweisungen importieren und dann Speichern. Und hier in der
Bootstrap-Methode werden
wir überprüfen, ob wir
einen Prozess haben , der im
JWT-Token enthalten ist oder nicht. Ja. Wenn Sie also
hier keinen GDB-T-Schlüssel haben , wenn Sie diesen nicht haben, kehren
wir zurück
oder geben einen neuen Fehler aus. Und es wird eine
Nachricht mit der Aufschrift Datenbank haben. Ordnung, jetzt speichern wir das, gehen zurück hierher, schließen
die Datei main.js
und gehen zu dem Prozess, der in
diesem JWT-Schlüssel ist. Wir müssen hier also
ein Ausrufezeichen hinzufügen , da wir bereits
in der Datei main.js nachgesehen haben. Wenn wir es nicht getan haben, haben wir den DWT-Schlüssel nicht
bekommen. Wenn wir die App ausführen, geben
wir einen Fehler und starten die API nicht. Jetzt müssen wir hier
ein neues Objekt hinzufügen. Und wir werden die
Gültigkeitsdauer im Eigentum hinzufügen. Und hier können wir die Zeit
definieren
, in der dieses
JWT-Token abgelaufen sein soll. In meinem Fall möchte
ich dieses
Token also in sieben Tagen ablaufen lassen. Sie können also wählen,
wann immer Sie möchten. Speichern wir das. Und natürlich können wir solche
Tage hinzufügen. Wenn Sie hier mit der Maus über
einem exponierten Grundstück fahren, werden
Sie feststellen, dass es außer wie Zeit mit Sekunden oder nur mit einigen
Zeichenketten wie dieser, zwei Tage oder 10 Stunden, sieben Tage ist. Es gibt viele Möglichkeiten, die Zeit hier zu definieren. Nachdem wir
das JWT-Token erstellt haben, müssen
wir nun ein Objekt
mit dem Benutzer und dem JWT zurückgeben, und es wird auf das JWT-Token
gesetzt. Jetzt ist der Fehler
verschwunden, da wir hier den
richtigen Wert
zurückgeben. Und wir müssen immer noch
überprüfen, ob wir einen Benutzer
mit derselben E-Mail haben , die bereits
in der Datenbank existiert. Dafür müssen wir also eine neue Methode
im User Service
erstellen. Und es wird
benannt werden. Finde einen per E-Mail. Und wir werden
die E-Mail als Zeichenfolge erhalten. Und dann
kehren wir 08 zurück und verwenden
das Benutzer-Repository , um schnell
die E-Mail hier zu finden. Speichern Sie das jetzt und
kehren Sie zu den Resolvern zurück. Und hier erstellen Sie eine neue
Konstante und nennen Sie sie,
exist oder existierender Benutzer. Und hier werden wir den Benutzerservice
verwenden, der eine per E-Mail
findet und die
E-Mail aus Eingaben diese E-Mail. Und darauf müssen wir warten. Und dann speichern. Und wir müssen überprüfen, ob
wir einen bestehenden Benutzer haben, dann müssen wir einen Fehler
zurückwerfen. Und für den Fehler müssen
wir eine ganz
bestimmte Art von
Fehlern verwenden , die
von oder mit GraphQL stammen. Und das ist ein GraphQL. Und wir können es
aus einem Graph Deal importieren. Ja, also wenn Sie Graph hier nicht
installiert haben, stellen Sie
sicher, dass Sie es
installiert haben und auch die Typen für GraphQL installiert haben. Und hier
müssen wir eine Nachricht hinzufügen. Die Nachricht wird also
lauten, dass der Benutzer bereits existiert. Und wir können einfach eine Nachricht
zurücksenden oder wir können einige andere Konfigurationen
hinzufügen, wie die Erweiterung
oder die Erweiterungen. Und hier können wir den
Code dieses Fehlers hinzufügen. Also noch ein Objekt
hier, Code Property. Und ich werde einen schlechten Anforderungscode
zurückschicken. Wenn Sie also einige
Informationen zu diesem Fehler
zurücksenden möchten , wie vielleicht die Felder oder
den Fehler, geben Sie diesen ein. Sie können all das hier
in das
Erweiterungsobjekt einfügen , und es wird
an den Client gesendet. Natürlich, wenn Sie
mit
create einen benutzerdefinierten Fehler erstellen möchten , wie wir es in den
anderen beiden Projekten getan haben. Erstellen Sie eine separate
Klasse für den Fehler. Und natürlich müssen Sie
hier immer
noch GraphQL verwenden , um diese Klassen zu erstellen. Aber es ist wirklich nicht
erforderlich, da wir bereits eine Klasse haben
und sie
jedes Mal verwenden können , wenn wir einen Fehler auslösen
möchten. Und es wird analysiert, wenn es
das Diagramm interessiert oder ja, wir müssen daraus
keine neuen Klassen erstellen. Nun, das war's für
die Anmeldemethode. Im nächsten Video erstellen wir
die Anmeldung.
18. signin erstellen: Jetzt können wir hier nicht an dem
Zeichen einer Mutation arbeiten. Also die Resolver,
weil wir das Zeichen bei
Mutationen immer noch nicht definiert haben, sind das Schema. Also lasst uns
das zuerst machen und dann zurück
zu den Earth Resolvern gehen. Genau hier. Lassen Sie uns die Mutation festlegen, Lassen Sie uns die
Site als Mutation erstellen. Und wir erhalten eine Eingabe
vom Typ, Anmeldeeingabe. Und übrigens,
wir können hier eine andere
Struktur verwenden. Anstatt also
ein Argument und die Zeit
für dieses Argument hinzuzufügen , können
wir hier alle
Argumente definieren, wie eine E-Mail vom Typ string. Und es ist erforderlich. Und dann füge ein Komma hinzu und wir
benötigen ein Passwort als Zeichenfolge. Ja, aber da wir
die Typen auch in
unseren Resolvern verwenden , innerhalb unseres Benutzerdienstes, müssen
wir den
Eingabetyp hier als Objekt definieren. Ändern wir das also auf die
Eingabe-Anmeldeeingabe, und
diese wird erforderlich sein. Auch hier werden wir eine Antwort der Erde
zurückgeben. Und natürlich ist es erforderlich. Jetzt müssen wir
die Anmeldung hier hinzufügen, eine
Eingabe, die hier erstellt wurde. Eingabe und Anmeldeeingabe. Wir benötigen nur die
E-Mail als Zeichenfolge, und sie wird
mit dem Passwort
als erforderlicher Zeichenfolge erfasst . Stimmt es? Jetzt speichern wir das
und öffnen das Terminal. Und wir müssen das Schema
generieren. Also npm run, generate originary
den Typ des Schemas. Ordnung, schließen Sie jetzt das Terminal und schließen Sie die GraphQL-Datei mit
dem Schemapunkt und kehren Sie hier in
die Autoren-Solver zurück. Unter der Anmeldung. Definieren wir das oder
unter der Anmeldung, definieren
wir die Anmeldemethode. Wir sollten hier eine Nachfolge
für diese Methode bekommen. Warte hier einfach eine Sekunde. Loggen Sie sich ein. Und wenn Sie den Mauszeiger darüber bewegen, werden
Sie feststellen, dass Sinus
n vom Typ Resolver ist. Also haben wir
die Typen korrekt generiert. Also hier sind das die definierte aktuelle
Eingabe und die Kontexte. Und wie ich bereits sagte, werden
wir
über die Kontexte und
nur über die zukünftigen Videos sprechen . Ja, also hier
müssen wir überprüfen, ob wir einen Benutzer mit dieser E-Mail in der Datenbank
gespeichert
haben. Also werde ich
diese beiden Zeilen aus der
Anmeldemethode
hier kopieren und hier einfügen. Und ändere das mit nur einem Benutzer. Hier. Wenn wir das nicht tun, wenn wir keinen Benutzer hatten, senden
wir
einen langen schriftlichen SO-Fehler zurück. Also hier falsch, Cree-Potenziale, Outer und der Code
immer noch schlechte Anfrage. Und dann müssen wir
überprüfen, ob wir das haben, ob die Passwörter
in der Eingabe dem Gefahrenpasswort
aus der Benutzerdatenbank
entsprechen. Fügen wir also eine Konstante hinzu
und benennen sie korrekt PWD und warten dann auf B-Krypt. Und das müssen wir importieren. Also dieser Hund Alport ist
eine korrupte Klasse aus
den entschlüsselten Paketen. Und hier werde ich
die Methode zum Vergleichen verwenden. Und diese Methode
akzeptiert den Puffer oder die Eingabe und vergleicht ihn
dann mit dem
Acid-Passwort. Ja. Also hier Passwort eingeben. Und dann erhalten wir das Gefahrenpasswort
aus dem Benutzerpasswort. In unserem Fall können
wir das
Passwort jedoch nicht vom Benutzer erhalten. liegt daran, dass
wir innerhalb
der Benutzerentität den
Buzzword-Kanon gesagt haben: Wählen Sie Falsch aus. Und deshalb werden wir
hierher kommen und definieren oder nicht. Ja. Aber wir können diese
Seite ändern, den Benutzerservice, und stattdessen finden sie eine per
E-Mail, die sie entfernt hat, eine nach Methode. Hier. Lassen Sie uns einen Query Builder erstellen. also aus dem Benutzer-Repository Erstellen Sie also aus dem Benutzer-Repository einen Query Builder. Und hier
deklarieren wir eine Variable
und nennen sie user. Und entspricht Query
Builder. Hier. Fügen Sie eine Idee für den Benutzer hinzu, und dann verwenden wir eine Methode, um das Benutzerkennwort
auszuwählen. Also hier, Benutzerpasswort,
jetzt die Abfrage. Es gibt jedoch eine Methode
, die beim Erstellen von
SQL-Abfragen hilft , indem sie einfach
einige andere Methoden wie diese hinzufügt. Ja, also werden wir hier eine Folgeabfrage erstellen und
degenerieren, indem wir den
Query
Builder verwenden , um das Benutzerkennwort
auszuwählen. Und dann suchen oder
wählen wir einen Benutzer aus, bei dem die E-Mail einer E-Mail entspricht. Hier definieren wir
die Variable E-Mail. Was hier also passiert,
ist, dass wir überprüfen werden, ob die E-Mail dieser Variablen
entspricht, ja. Und um Variablen
in dieser Abfrage hier zu definieren, fügen
wir den Doppelpunkt und dann
den Namen der Variablen hinzu. Und dann haben
wir im
zweiten Argument hier ein Objekt, das die Werte dieser
Variablen enthält , und es sollte
denselben Namen haben, den wir hier geschrieben haben. Wenn wir
den Query Builder hier ausführen, wird
dies daher in
email equals und dann in
die E-Mail des Benutzers geändert . Jetzt brauchen wir
hier eine andere Methode, um einen Benutzer zu bekommen. Und wenn Sie den Mauszeiger über den Benutzer
bewegen, wird dieser Benutzer als
Versprechen angezeigt, das
entweder einen Benutzer zurückgibt oder nicht. Deshalb
müssen wir hier warten, und dieses Mal werden wir entweder
einen Benutzer bekommen oder nicht. In diesem Fall geben
wir
den Benutzer zurück und speichern
den Benutzerdienst. Geh wieder her. Oder gehen wir zurück
zum Benutzerservice. Und hier habe ich vergessen zu erwähnen , dass wir hier
eine Auswahl hinzufügen sollten. Ja, dies wird die primäre
Auswahl sein und wir werden das Benutzerdokument
oder alle Spalten anstelle
des Benutzerdokuments auswählen . Und dann fügen wir eine Auswahl hinzu, wo wir das Passwort
verwenden werden. Und dann filtern wir hier und schicken dann den
Benutzer mit dem Passwort zurück. Leider versteckt
die Select-Force hier nur das Passwort
vor den Suchmethoden. Also entweder finde einen oder
finde nach etwas. Ja, aber das Passwort wird nicht
versteckt. Wenn wir den Benutzer hier speichern
oder eine neue Entität speichern. Daher müssen wir hier
in der Methode
create eine Konstante erstellen. Erstellen Sie eine Konstante, die den Dienstbenutzer
enthält, und erstellen Sie danach hier eine weitere
Find-Methode. Und suche nach dem
Benutzer mit der ID. Ja, aber das wird
Zeitverschwendung sein, besonders wenn Sie mit GraphQL
arbeiten. Denn mit GraphQL können
wir Passwörter
oder irgendetwas anderes verstecken, indem wir einfach die Felder hier
entfernen. Für das Passwort können wir also das Passwortfeld
entfernen. Und dann erhalten wir innerhalb
der Off-Antwort, innerhalb des Benutzers, das Passwort
nicht. So verstecken wir
Anmeldeinformationen mit GraphQL. Aber hier wollte ich Ihnen nur
zeigen, wie Sie mit dem
Create Query
Builder
ein Höhenfeld aus der Datenbank abrufen können ein Höhenfeld aus mit dem
Create Query
Builder
ein Höhenfeld aus der Datenbank wenn Sie GraphQL nicht verwenden. Also werde ich diesen
Code so belassen Sie sich daran erinnern, wie
Sie einen hohen Tunnel bekommen, wie das Passwort
und die traurige Benutzerentität Ich werde hier
die Option Falsch entfernen ,
weil ich nicht ändern oder schreiben möchte jedes Mal
den gleichen Code ändern oder schreiben möchte, wenn
ich die Entität erhalten möchte. Und ich werde eine
gemeinsame Stufe zwei hinzufügen. Um darauf hinzuweisen, können
Sie diesen Ansatz
nur verwenden, wenn Sie ein Versteck haben. Also hier nur, wenn
die Entität , dass Carlin und Sie
die Auswahl auf falsch gesetzt haben. Speichern Sie nun den Benutzerdienst und schließen Sie diese beiden Dateien
und kehren Sie hierher zurück. Und das ist eine sehr schnelle Fortsetzung
der Anmeldemethode. Jetzt müssen wir
überprüfen, ob wir das richtige Passwort nicht hatten oder nicht, dann geben wir einen Fehler zurück. Und hier fehlt mir die Luft, korrigieren oder sehen und hören, werfen einen neuen Graph Girl Error. Und es wird
dieselbe Nachricht sein , Ihr
Ausweis, falscher Ausweis. Und die gleiche Erweiterung. Also lass mich das kopieren. Und hier
kopiere ich die Erweiterung. Und dann müssen wir
das JWT-Token regenerieren und dann
den Benutzer mit dem JWT zurückgeben. Also werde ich
das kopieren und hier einfügen. Jetzt wird der Benutzer mit dem Passwort
zurückgegeben. Aber weil wir
das innerhalb des Schemas geändert
haben, kehren wir nicht zurück oder
das Graph Gear
wählt das Passwort nicht aus der Return-Anweisung
der Mutationen hier aus. Jetzt
müssen Sie natürlich Ihr Terminal öffnen und npm
run degenerate ausführen, da
wir das Schema aktualisiert haben. Also lass uns das machen. Npm run generate. Und das war's. Wir haben die Arbeit an
der Anmeldemethode abgeschlossen.
19. Arbeiten mit dem graphql: Jetzt erstellen wir
eine Abfrage , die die
Benutzer-E-Mail und die Benutzer-ID zurückgibt. Und wieder
beginnen wir mit dem Schema. Erstellen GraphQL und Crea eine neue Abfrage und benennen
sie als aktuellen Benutzer. Und hier
schicken wir eine JWT-Payload zurück. Jetzt müssen wir diesen Typ definieren. Kopieren Sie also den JWT-Namen
und erstellen Sie hier den Typ, dann JWT, blenden Sie ihn aus und zitieren Sie ihn. Wir werden die
E-Mail vom Typ string haben
und wir werden die
Benutzer-ID vom Typ int haben. Und beide sind erforderlich. Jetzt speichern wir das, schließen das Schema, das GraphQL und wir müssen die Typen
generieren. Führen Sie npm aus, führen Sie das Terminal aus, generieren Sie es
und schließen Sie es. Gehen Sie zurück zu den Autorenresolvern. Und hier in der Abfrage entfernen
wir die
get-Methode von hier. Und die aktuelle Benutzermethode. Ich höre es. Elternteil, wir brauchen
den Input und die Kontexte. Ordnung, jetzt haben wir hier
einen Fehler, weil wir der aktuellen Benutzerabfrage
keine Eingabevariable
hinzugefügt haben, als ob wir die Mutation nicht
zugewiesen haben, also werden wir hier kein
Eingabeargument erhalten. Also lass uns das entfernen und
es so durch unser x ersetzen. Und nur um
klarzustellen , dass wir keine Argumente
haben, werde
ich es
durch ein leeres Objekt ersetzen. Ordnung, jetzt werden
wir
die JWT-Payload
aus dem JWT-Token extrahieren . Aber wir haben
diese Logik früher
einer Middleware hinzugefügt und
diese Middleware dann
in anderen Routern verwendet . Und dann holen Sie sich ein Objekt aus den Anfragen,
die die Nutzlast des Benutzers enthalten. Aber das ist natürlich
in einer RESTful-API. Aber weil wir
Express mit GraphQL verwenden, können
wir dasselbe tun. Wir können hinzufügen. Wir können ein Create
Image verwenden und dann die 2s-Methode verwenden
, um den Mittleren Westen hier
anzuwenden. Und dann bekommen wir das, wir können die
JWT-Payload aus dem JWT-Token extrahieren. Wir können
den gleichen Prozess jedoch mit dem
Apollo-Server implementieren , indem wir
einen Kontext hinzufügen ,
der die Anfrage und
die JWT-Payloads enthält . Also hier, sagen wir den
Apollo-Server in einem Kontext. Und es wird eine Funktion
sein, die ein Objekt zurückgibt. Bevor wir mit
der Arbeit an dieser Funktion beginnen, müssen
wir eine neue Schnittstelle hinzufügen
und ihr Kontexte nennen. Also hier, Exportschnittstelle,
dann mein Kontext. Wir müssen
den Express-Inhalt erweitern , damit wir auf die Anfrage zugreifen können
. Und hier werden wir
unsere benutzerdefinierten Eigenschaften hinzufügen. Aber zuerst müssen wir die Express-Kontexte
vom Apollo-Server
importieren . Also hier, Airport
Express-Kontext von einem
Fotoserver Express. Nun hier, das ist unsere
erste benutzerdefinierte Eigenschaft, nämlich der aktuelle Benutzer. Und es wird
vom Typ T, W T Payload sein. Und die DWT-Nutzlast wird
aus den verbrannten Typen importiert . Stellen Sie also sicher,
dass Sie das von diesem Pfad hier importieren. Dann müssen wir
eine weitere Immobilie hinzufügen, die das
autorisierte Eigentum ist. Und mit dieser Eigenschaft können
wir überprüfen, ob wir einen
autorisierten Benutzer haben oder nicht. Diese Eigenschaft wird
also vom Typ Boolean sein. Und spar dir das. Geh wieder her. Und wir müssen die
Mike-Kontext-Schnittstelle
zum Apollo-Server hinzufügen . Also werde ich den Apollo-Server
mit meinen Kontexten zurückgeben , meinen Kontexten. In Ordnung, jetzt gehe zurück
zu dieser Methode hier. Und jetzt können wir extrahieren. Extrahieren Sie aus der Funktionsstörung die Anfrage und die Antwort, da wir die Express-Kontexte
erweitert haben. Und hier erstellen wir eine
Konstante und nennen sie Payload und verwenden dann die
DWT-Pakete von DWT, das müssen
wir importieren. Also lass es uns machen. Wichtig, JWT von Jason Token hier, CWT dot verify, um das Token zu
verifizieren. Und dieses Mal erhalten wir
das Token nicht aus der Sitzung, sondern aus den Headern. Also werden wir die
Anforderungspayload oder die Tether verwenden. Stellen Sie sicher, dass Sie
Header und keine Tether auswählen. Und dann holen wir uns das Token aus dem
Autorisierungsheader. Ja. Die Heather's können also nein sein. Fügen wir dort also ein
Fragezeichen hinzu. Und jetzt müssen wir
den geheimen JWT-Schlüssel weitergeben. Ich kann das also
von
der DWT-Taste abrufen und
ein Ausrufezeichen hinzufügen. Wir können TypeScript also sagen
, dass dies nicht Null ist. Und jetzt müssen wir
die Nutzlast hierher zurückgeben. Also eine Bestellung hier, denn es scheint
, dass die Anfrage auch neu oder undefiniert sein kann. Fügen wir dort also ein
Fragezeichen hinzu. Oder lassen Sie uns einfach überprüfen, ob wir keine Anfrage
erhalten haben. Ja, wir werden
ein Objekt zurückgeben und wir werden in einer Sekunde hierher
zurückkommen. Definieren wir nun die
aktuelle Benutzereigenschaft und geben ihr die Payload. Und dann senden wir die Anfrage auch zurück oder leiten
sie an die Resolver weiter. Und dann nehmen wir das
autorisierte Eigentum, und das autorisierte
Eigentum ist ein boolescher Wert. Wir werden also prüfen, ob Sie eine Payload
haben oder nicht. Wenn Sie also keine Auszahlung erhalten haben ,
bedeutet das, dass der Benutzer nicht autorisiert
ist. Dafür werde ich eine spezielle Syntax
verwenden. Also unsere beiden Ausrufezeichen
und dann hat Abby ausgezahlt. Wenn die Payload also
null oder undefiniert ist, das erste Ausrufezeichen
den Wert true zurück. Dann gibt das zweite
Ausrufezeichen das Gegenteil
von wahr zurück, was falsch ist. Und dann haben sie autorisiert, es wird auf
false gesetzt, was bedeutet, dass der Benutzer nicht autorisiert
ist, weil
wir eine Null haben, ein Pilotprojekt. Wenn wir nun keine Anfrage
hätten, ist
das
für uns ein Problem , da wir das JWT-Token nicht
extrahieren können. Also senden wir a
auf dasselbe Objekt, aber
mit dem koreanischen Auswahlmenü, das
auf Null gesetzt ist und die Anfrage
natürlich und das
autorisierte Objekt auf Falsch gesetzt ist. Wir müssen das zurückgeben. In Ordnung, lassen Sie uns jetzt
die Fragezeichen von hier entfernen. Und eigentlich müssen
wir hier überprüfen ob wir hier keinen Request for
Authorization Header bekommen
haben oder nicht , dann schicken wir dieses Objekt einfach
zurück. Andernfalls
extrahieren wir die Payload und senden die erforderliche Eigenschaft. Lassen Sie mich nun diesen
Code ein wenig
anpassen und diese Datei speichern. Schließen Sie es dann und
kehren Sie zum koreanischen
Benutzerresolver oder zur Abfrage hier zurück. Und wir werden überprüfen, ob das autorisierte Eigentum
im Kontext liegt. Wahr oder falsch. Ja. Also wenn das autorisierte
Eigentum also hier autorisiert ist. Und wir bekommen keine
Autorisierung aus dem Kontext. Das liegt daran, dass wir die Codekette hier
aktualisieren müssen. Ja, und aktualisiere die
Typen der Ergebnisse. Wir müssen also
den Kontexttyp angeben und
dies hier in der Konfiguration angeben. Und auf derselben
Einrückungsebene, Kontexte, Typen oder Kontexte, Typen nach Typ und geben den Pfad oder die Datei an, die unseren Kontext
enthalten. In unserem Fall
existieren meine Kontexte in der Moduldatei. Stellen Sie also sicher, dass Sie zuerst
die Mike-Kontext-Schnittstelle
exportieren und hierher kommen und
die Geburt entsprechend
diesen generierten Ordnern hinzufügen . Also je nach dem
generierten Ordner, dem Modul oder
dem Resolvertyp, der neben dem
generierten Ordner existiert. Die Moduldatei befindet sich eine
Ebene weiter, dann das Modul. Und wir müssen
die Schnittstelle auswählen. Also fügen wir
hier einen Hashtag hinzu und fügen den Namen
der Kontexte hinzu. Also meine Kontexte. Und in diesem Fall wählen
wir mithilfe
einer YAML-Syntax a, a, eine exportierte Schnittstelle
oder Variable eine exportierte Schnittstelle
oder Variable
aus der Datei aus. Schließen wir nun die
Co-Gen-Konfigurationsdatei und öffnen das Terminal. Dann müssen wir hier
die Generatorbefehle ausführen. Also npm run generate, und dann erhalten wir unseren
Typkontext, meinen Kontext. Ja. Also lasst uns warten. Gerade jetzt. Wenn Sie den Mauszeiger über Kontexte
bewegen, sollten Sie hier den
Fahrradkontext eingeben. Lassen Sie mich nun das Terminal schließen und authorized ist
vom Typ Boolean. Wir überprüfen also, ob
der Benutzer nicht autorisiert ist, senden
dann einen nicht autorisierten Fehler
zurück. Throat wusste also, dass GraphQL
und MS nicht autorisiert sind. Und wir müssen eine Erweiterung hinzufügen. Erweiterung. Dann füge den Code hinzu. Und hier werden wir den Code hinzufügen. Unbefugt. In Ordnung? Wenn wir nun eine Autorisierung für
diesen Benutzer haben oder aus dem
Kontext zurückkehren
möchten, der aktuelle Benutzer. Jetzt lasst uns sparen. Der aktuelle Benutzer ist vom Typ G Deputy Payload enthält
die E-Mail und die Benutzer-ID. Der Typname hat nur
etwas mit GraphQL zu tun. Aber innerhalb des
GraphQL-Schemas oder einer Antwort erhalten
wir nur
die E-Mail und die Benutzer-ID. In Ordnung, jetzt speichern wir das. Und um all
diese Resolver hier testen zu
können, benötigen wir eine
funktionierende Datenbank. In den nächsten Videos werden
wir natürlich lernen, wie
man Joker benutzt, wie man Docker installiert
und dann Docker verwendet um die Postgres-Datenbank zu installieren und sie in unserem lokalen System auszuführen.
20. Was ist Docker: Docker teilt ein
laufendes Linux-System in kleine Container auf, was eine eigene kleine Welt
mit seinen eigenen Programmen
und seinem eigenen Alles ist ,
alles isoliert von allem anderen. Diese Behälter sind so
konzipiert, dass sie tragbar sodass sie
von einem Ort zum anderen transportiert werden können. Und Docker erledigt die
Arbeit, um
diese Container zu
und von Ihren Systemen zu transportieren. Nun, was ist der Container? Weißt du, wenn du
etwas mit zB
einem OTS baust und dann
deinen Code in GitHub schiebst und jemand anderes
versucht,
deinen Code in
seinem lokalen System abzurufen und auszuführen , aber es hat bei ihm nicht funktioniert. Und dann wird er denken
, dass dein Code Müll ist. Und Sie denken vielleicht auch, dass
Sie kein guter Entwickler sind. Manchmal ist dies jedoch nicht der
Fall, da Ihre Node.JS -Anwendungen eine
sehr spezifische Software
und eine einzigartige Umgebung benötigen , um zu funktionieren. Und diese Anforderungen gibt es
nur in
Ihrem lokalen System, wo Sie sich befinden,
wo Sie
Ihre Node.JS Anwendung entwickelt haben . Wenn Sie beispielsweise
Linux und anstelle von Windows haben oder wenn Sie eine
ältere Version von Knoten haben, ja, all diese Variablen können nicht
in allen Systemen gleich sein. Aus diesem Grund hat Docker einen sogenannten Container
eingeführt. Ein Container ist eine standardisierte
Softwareeinheit
, mit der Entwickler
problemlos von
ihrer Umgebung aus Daten zugreifen können . So können Sie z. B.
Ihre Node.JS Anwendung
entwickeln und einen Container darum herum und
ihn als Image auf
Docker Hub übertragen. Und dann kann jeder
dieses Image abrufen und es in
seinem eigenen lokalen System ausführen. In diesem Fall wird Ihre
NodeJS-App derselben Umgebung
wie in Ihrem lokalen System
ausgeführt.
21. Docker Linux installieren: Um Docker nun auf
Ihrem Fenster oder auf einem
Linux-System im Allgemeinen zu starten , müssen
Sie einige
Schritte ausführen. Also sieh dir dunklere Tags an. Und Sie können diesen
Pfad hier oder diese URL verwenden. Und vielleicht können Sie bei Google nach der
Installation der Docker-Engine
auf Ihrem Pinto
suchen , da URLs
in Zukunft geändert werden können. Das erste, was
Sie
hier tun müssen , ist sicherzustellen, dass Sie keine ältere
Version von Docker
haben. diesen Befehl hier ausführen, können
Sie alle
veralteten Versionen löschen. Der nächste Schritt ist nun,
dass Sie Ihre APT-Pakete aktualisieren müssen. Und dann fange ich mit ein
paar Bettlern an und schaue, ob das in den nächsten Schritten
verwendet wird. Ja, dann müssen
Sie diese Befehle ausführen um Ihrem System mitzuteilen
, dass es in Ordnung ist, es zu benutzen. Die Software stammt von
der Docker Engine. Und dann müssen Sie
diesen Befehl ausführen , um Ihr Repository
einzurichten. Und der Grund, warum
wir
unser Repository hinzufügen oder ein Repository
einrichten müssen unser Repository hinzufügen oder ein Repository
einrichten , das mit der
Docker Engine verbunden ist, ist, dass
wir Bilder
aus Docker Hub abrufen werden. Und manchmal müssen wir von
uns erstellte Bilder an den Docker Hub übertragen. Wir brauchen also
solche Flughäfen. Es ist ähnlich wie Repositorys
mit GitHub. Ja. Der nächste Schritt ist nun die
Installation der Docker Engine. Nach dem Einrichten
ihres Repositorys. Natürlich müssen Sie Ihre Pakete erneut
aktualisieren. Und wenn Sie
Fehler haben, führen Sie diese Befehle aus. Und schließlich
können Sie Docker installieren, indem Sie diesen Befehl
ausführen. Wenn Sie anschließend überprüfen
möchten, ob Sie Docker erfolgreich
installiert haben, können
Sie ein Image
namens Kilowatt ausführen
, das
standardmäßig mit Docker vorhanden war . Führen Sie also diesen Befehl aus, sudo docker run hello-world, und Sie sollten eine Zeichenfolge mit HelloWorld
zurückerhalten.
22. Bilder zu Containern: Nachdem wir
Docker installiert haben und ein wenig
darüber gesprochen haben, was Docker ist, wollen wir versuchen, es zu verwenden. Bei Docker
beginnt also alles mit einem Image. Ein Image ist jede
Datei, die
gerade genug vom
Betriebssystem ausmacht ,
um das zu tun, was Sie tun müssen. Der Befehl
zum Betrachten Ihrer Docker-Images
lautet jetzt einfach Docker-Images. Sie können hier sehen
, dass ich viele
Bilder und Dinge habe, die hier vor sich gehen,
weil ich die ganze Zeit
Obcura Bilder und Dinge habe, die hier vor sich gehen, verwendet habe. Und für dich hast du vielleicht
ein paar Bilder, als wärst du auf HelloWorld
gewesen. Jetzt hat das Bild einen
Namen und eine Version, bike latest oder
so ähnlich. Und auch sein Bild hat eine ID. Und hier können wir herausfinden, wann
dieses Bild erstellt wurde. Und hier können Sie
die Größe dieses Bildes sehen. Lassen Sie uns nun ein Image aufnehmen und es
dann mit Docker im
Container ausführen. Lassen Sie mich dieses Terminal leeren
und dann den rechten Docker ausführen. Befehl ausführen. Dieser Befehl nimmt nun ein
Bild und verwandelt es in einen lebenden laufenden Container mit einem Prozess, der etwas
tut. Jetzt, nach dem Docker-Run, gebe
ich das
Image an, das sie verwenden möchten. Und für mich werde ich verwenden
, wer schon dort war. Und für Sie, falls Sie
es nicht gefunden haben, dass Sie
standardmäßig in Ihrem Joker installiert wurden . Sie sich keine Sorgen, denn wenn Sie diesen Befehl
ausführen, versucht
Docker
, den Menschen mit der neuesten
Version vom Docker Hub auf ein
Image zu bringen. Dazu müssen Sie natürlich
eine Internetverbindung
haben . Jetzt bin ich mit diesem Befehl hier immer noch nicht fertig
. Also Docker Run, das warst du schon. Und dann haben wir gesagt
, dass wir in diesem Bild einen Prozess
ausführen werden. Lassen Sie uns also die
Bash-Shell ausführen, weil ich einige
Befehle in Ihrem Terminal ausführen
möchte . Und auch dafür benötigen
wir eine Flagge, um
mit dem Terminal zu interagieren. Und die Flagge ist die D-Flagge. D steht also für
Terminal und I steht für Interactive,
Terminal und Directive. Dann warst du auf Bash. Und jetzt lassen Sie uns diesen
Schaltplan für Sie ausführen. Wenn Sie noch nicht dort waren, wird ein
Download-Vorgang angezeigt. In Ordnung, wir sind
im Ubunto-Bild. Nun, wenn ich hier nachschaue, werde
ich feststellen, dass wir
in der,
Sie waren in der Umgebung, in der wir sind , sind. Und nur um
sicherzugehen, dass Sie
diesen Befehl ausführen , um sich
diese Datei anzusehen . LSB Dash Release. Und wir sollten die Version bekommen die du hier haben wirst, die Version 20 und
die Distributions-ID. Du gehst jetzt zu
deinem Ausgang dieses Bild. Du kannst exit wie folgt schreiben
oder Control D tut es für exit. Um
das zuletzt geöffnete Bild zu sehen, können
wir hier ein neues Terminal öffnen ps docken
und
dann die neueste Version löschen. Wenn Sie also nur
ps ausführen, werden Sie feststellen, dass
Sie alle
laufenden Bilder erhalten. Und mit L können Sie
das zuletzt geöffnete Bild abrufen. Wenn Sie diesen Befehl ausführen, werden
Sie feststellen, dass das Bild
das ist, das Sie schon einmal besucht haben. Und Sie finden hier den Befehl , mit dem
Site dieses Bild ausgeführt wurde. Und natürlich, wo
wird es erstellt? Und es wurde vor
ungefähr 4 Minuten beendet. Ja. Und das ist nicht der Name
dieses Containers, nicht das Bild. Dieser Container
bewirtschaftet also das
Stadtbild und
das Korbland. Ja. Und es wurde
vor 6 Minuten erstellt und vor 4 Minuten beendet. Und das ist die Idee
des Containers. Und sie sagten den Namen
des Containers. Dieser Name wird übrigens zufällig von Docker generiert. Gehen wir jetzt zurück
hierher und führen das aus, Sie haben das Image erneut
mit der Bash-Shell aufgerufen. Und darin warst
du schon bei einem Bild. Lassen Sie uns mit
dem Touch-Befehl eine neue Datei erstellen und sie meine Datei nennen. Und schauen Sie hier nach und
wir werden meine Akte finden. Dann lass uns das beenden. Oder ich lasse diesen Container
laufen und gehe
hierher zurück und führe dann
denselben Befehl aus,
Docker, führe TI für
Terminal Interactive aus. Und dann warst du in der Bash-Shell
und hast sie ausgeführt. Wir führen also
dasselbe Bild mit derselben Flagge im
selben Prozess aus. Und hier, wenn wir einen Blick darauf werfen, werden
wir die Datei, die hier erstellt wurde
, nicht finden. Sein Container
führt also ein Image aus und er wird nicht von
anderen Containern beeinflusst , die dasselbe Image
ausführen. Wenn wir hier eine Datei erstellen, heißt das nicht, dass
wir
dieselbe Datei in
diesem Container erhalten dieselbe Datei in , auf dem dasselbe Image
ausgeführt wird. Sein Behälter ist also vom anderen
isoliert. Obwohl beide dasselbe Image
ausführen, können
Sie sie sich wie
zwei Computer vorstellen , auf denen dieselbe
Version von Ihnen ausgeführt wird.
23. Container zu Bildern: Jetzt können wir sehen, dass wir
von einem Image zu einem
laufenden Container übergegangen sind. Und wenn wir einen Container starten, ist
der Container immer noch da.
Es wurde nicht gelöscht. So kann ich mir
den zuletzt
verlassenen Container
mit einem Docker-PS-Befehl ansehen den zuletzt
verlassenen Container
mit . Aber natürlich benötigen wir
die Dash L-Flagge, um den
zuletzt gestoppten Container zu bekommen. Hier kannst du also sehen, dass ich einen Container
habe, der gerade noch
lief. Und Sie können alle
Informationen
zu diesem Container hier sehen . Nehmen wir an, ich habe
einen gestoppten Container. Ich habe mit einem Basisimage angefangen. Ion hat meine eigene Software gestartet. Ich habe einen Container, auf dem
meine Software installiert ist. Jetzt möchte ich in Zukunft
denselben Container verwenden, in dem meine eigene Software enthalten ist, oder ihn vielleicht
mit der Community teilen. Dazu müssen
wir also den Befehl docker
commit verwenden, Container
nimmt und daraus Images erstellt. Um den Docker-Commit zu verwenden, erstellen
wir zunächst einen neuen
Container. Lass uns das klären. Und eins. Du warst dort, natürlich mit dem TI-Flag und dann warst du dort und hast den Batch-Befehl
ausgeführt. In diesem Container erstellen
wir nun eine Datei, und wir müssen
diese Datei in Zukunft
mit diesem Container verwenden . Also werden wir hier ein Bild aus
diesem Container
erstellen , das
den Befehl touch und create
file verwendet und es wie Secrets benennt. Wir haben unsere Akte hier. Lassen Sie uns diesen Container mit Control D verlassen oder schreiben Sie
einfach exit. Und dann nehmen wir die Idee dieses Containers,
indem wir docker
ps dash L ausführen . Dann haben wir hier
die Idee dieses Containers. Kopieren wir also diese ID. Und dann verwenden wir den Befehl
docker commit und fügen die dunklere oder
die Container-ID hier führen
dann den Befehl docker
commit aus. Jetzt würden wir ein Bild
aus diesem Container holen. Und das ist die
Idee dieses Bildes. Aber eine solche lange ID zu verwenden, ist keine gute Sache,
da Sie diese
ID verlieren können oder es
schwierig sein
kann Befehle mit
dieser langen Zeichenfolge auszuführen. Was ich als Nächstes
tun werde, ist dieses Bild mit
einem für Menschen lesbaren Namen
zu taggen. Und um das zu tun, verwenden wir das Tag-Flag
nicht. Dann fügen wir die ID dieses
Bildes aus dem Doppelpunkt an das Ende dieser
Zeichenfolge hinzu und fügen sie hier ein. Und dann wähle einen
Namen für dieses Bild. Also stell dir vor, was zB und führe den Docker-Befehl aus. Und wenn wir nun überprüfen möchten,
ob Sie ein Bild mit dem Bildstrich oder
dem
Unterstrich unter einem Namen haben , können
Sie Docker-Images ausführen und dann hier nach dem
Image-Namen suchen. Sie finden ihn hier. Wir haben also das Bild, das eins unterstrichen hat, und hier haben wir die ID. Und es wurde vor wenigen
Minuten erstellt. So können wir also
Bilder aus Containern erstellen. Jetzt gibt es eine andere Möglichkeit, Bilder
zu übertragen,
anstatt den
Commit-Befehl zu verwenden. Und es ist Scharfsinn. zunächst Lassen Sie uns zunächst einen Docker-Container erstellen und die Idee
dieses Containers übernehmen. Dann werden wir den
Docker-Commit auf andere Weise verwenden. Also hier lasst uns
eine Datei wie meine Datei erstellen. Und lass uns wieder aussteigen. Und dann werden
wir überprüfen oder uns Bild von diesem
Docker-Container machen. Und jetzt können wir den
Namen des Containers annehmen. Hier ein menschenlesbarer Name, und kopiere ihn und führe dann docker aus, commit, dann den Namen
des Containers und dann den Namen
des neuen Images, das
Sie erstellen möchten. Und dieses Mal
wähle ich Bild zwei. Jetzt führen wir diesen Befehl aus. Wir würden die gleiche
Ausgabe wie zuvor erhalten. Aber wenn Sie jetzt
Docker-Images ausführen, können
Sie ein Image finden in unserem
lokalen Docker-Repository präsentiert werden
soll.
24. Postgres-Datenbank mit Docker ausführen: Jetzt werden wir
mehr über Docker lernen und
gleichzeitig unsere Postgres-Datenbank
betreiben. Und dafür müssen wir
das
Postgres-SQL-Image von Docker abrufen . Um das zu tun,
müssen wir Docker ausführen, Pull. Dann der Name des
Bildes, das Postgres ist. Sie können einen Doppelpunkt und
dann das neueste Tag hinzufügen. Aber standardmäßig installieren Sie die neueste Version. Jetzt werde ich
diesen Befehl nicht ausführen, da ich dieses Bild
bereits
in meinem lokalen System habe. Jetzt
verwende ich den
Befehl docker run , um das
Postgres-Image auszuführen. Natürlich mit dem DI-Flag
hier und dem Postgres-Image. Jetzt werden
wir diesen Befehl nicht ausführen. Nehmen wir das, weil wir einige Konfigurationen
hinzufügen müssen. Und dieses Mal
möchte ich einen benutzerdefinierten Namen
für meinen Container hinzufügen. Und dafür müssen wir
den Desktop Named Flag verwenden und dann einen Namen wie
up
wählen. Unterstreichen. Beide betonen. Um nun
eine Verbindung zur
Postgres-Datenbank herzustellen, müssen
wir einen Port verfügbar machen, und Postgres
verwendet nativ den 5432-Port, um Verbindungen zu
akzeptieren. Also müssen wir
diesen Port vom Container aus mit
dem Strich P-Flag sichtbar machen . Und jetzt müssen wir diesen Postgres-Port einem
Port aus dem Container zuordnen. Und ich wähle 545
5 V und füge hier einen Doppelpunkt hinzu. Nun, Sie haben wahrscheinlich nicht verstanden,
wovon ich hier spreche. Deshalb habe ich hier
ein Diagramm erstellt, um die Idee der Offenlegung
von Beiträgen zu
vereinfachen. Hier haben wir also den Postgres-, Postgres-App-Container oder
Output-Glascontainer. Lassen Sie mich also den
Namen hier bei Postgres ändern. Und in diesem Container läuft ein
Bild. Dieses Bild ist also
das Postgres-Bild. Und Postgres
verwendet nativ den 5432-Port. Wir können jedoch keine
App mit dem
Postgres-Image vom 5432-Port verbinden . Wenn wir dieses Bild
aus dem Container ausführen. Denn wie Sie wissen, sind
Container
voneinander und
vom lokalen System isoliert . Dieser Ansatz wird also nicht funktionieren. Daher
müssen wir eine andere Methode verwenden, nämlich ein anderes Board
aus dem Container freizulegen und diesen Port dem Postgres-Port oder dem Image zuzuordnen, das in diesem Container
läuft. Und um dann eine Verbindung
zur Postgres-Datenbank herzustellen, müssen
wir uns mit dem
lokalen Host-Colon 5455 verbinden. Wir müssen uns also mit
dem Container verbinden, nicht mit dem Bild selbst. Wenn Sie jetzt
mehr als einen von haben, können
Sie
sie natürlich mit demselben
Container verbinden , auf dem das Postgres-Image
ausgeführt wird. Weil wir hier localhost
verwenden. Aber es wird natürlich nicht
empfohlen,
dieselbe Datenbank mit
anderen Anwendungen zu verwenden dieselbe Datenbank mit
anderen Anwendungen da Sie Daten verlieren
und Ihre
Datenbanktabellen zerstören können , z. B. wenn App One
einen Benutzer
mit einer E-Mail a in der Datenbank registriert , dann haben
wir gleichzeitig die App auch, die auch einen Benutzer
mit derselben E-Mail
registriert. In diesem Fall
haben Sie statt
Ihrer Datenbank Benutzer
mit derselben E-Mail-Adresse, obwohl in Ihren Anwendungen
Validierungen ausgeführt werden, was
nicht verhindert, dass
ein solcher Fehler zu B passiert. Sie müssen also einen weiteren Container
mit demselben Bild
erstellen. Aber dieses Mal
musst du diesen Container mit einem anderen Namen benennen und dann
auch hier einen anderen Port verwenden. Aber natürlich behalten Sie den gleichen Port für
das Postgres-Image. Also hier wurde der Name geändert in, bis und hier das
Postgres-Icon. Wir haben also das
Postgres-Image hier und Sie müssen diesen Port ändern. Andernfalls können Sie keine
Verbindung zum Container herstellen, oder Sie können diesen Container nicht
erstellen da Sie hier denselben Port
in einem anderen Container
verwenden . Also ändere ich es einfach auf 5456. Und dann lass mich das entfernen. Der Outdo stellt eine Verbindung zu dieser Adresse her, zu diesem Container. Und
so können Sie, zum Beispiel beim Aufbau von Microservices,
das ist der richtige Ansatz, um
eine Verbindung
zur Datenbank herzustellen. Die App muss also über
eigene Container verfügen , in denen die Datenbank
ausgeführt wird. Nun, ich weiß nicht, warum ich so
immer wieder auf und ab
scrolle, aber lassen Sie uns das einfach ignorieren
und zurück in
unser Terminal gehen und
den App-Postgres-Container fertigstellen. Also haben wir unsere Beiträge hier. Jetzt. Wir müssen einige
Umgebungsvariablen definieren. Und es ist erforderlich, um Postgres
auszuführen oder
eine Verbindung zu Postgres herzustellen. Jetzt werden diese
Umgebungsvariablen auch hier definiert. Wir müssen also dieselben Informationen
wie
den Benutzernamen, das
Passwort und den Port definieren dieselben Informationen
wie
den Benutzernamen, das , und wir haben den Port 25455
geändert. Lassen Sie uns das jetzt hier ändern. Und die Quelle,
das Terminal hier, und versuche, die
gleichen Informationen zu kopieren. Um nun a, eine
Umgebungsvariable, hinzuzufügen, müssen
wir das
Dice e-Flag verwenden und dann die erste Variable benennen. Und die erste Variable
ist der Pfostenbinder. Und es sollte alles in Großbuchstaben sein. Jetzt unterstreicht Postgres den Benutzer. Es sollte derselbe sein
wie der Nutzername hier. Es wird also gleich Admin
sein. Und um eine weitere
Umgebungsvariable zu definieren, müssen
wir erneut
das G-Flag Dash verwenden und dann das
Postgres-Passwort schreiben. Auch hier alles in Großbuchstaben. Und dann ist das Passwort dasselbe Passwort in
der App-Datenquelle. Das Passwort ist also admin und die letzte
Umgebungsvariable ist der Datenbankname. Also nochmal heikel, dann Postgres. Also am krassesten. Unterstreichen Sie dann db für die Datenbank. Und der
DB-Datenbankname ist main. Kleinbuchstaben. Es sollte derselbe
Name sein wie hier dargestellt. Der Hostname
ist natürlich local host, da dieser Container in unserem lokalen System
ausgeführt wird. Lassen Sie uns nun diesen Container ausführen
und auf das Ergebnis warten. Los geht's. Wir haben hier einige
Logins im Gange. Und diese, diese Informationen beziehen
sich auf Postgres. Also initiieren wir eine neue
Verbindung zur Datenbank. Und los geht's, wir haben ein Datenbanksystem, das bereit ist, Verbindungen
zu akzeptieren.
25. Graphql testen: Damit unsere App nun eine Verbindung
zur
Postgres-Datenbank herstellen kann, müssen
wir
die App-Datenquelle
in module.js Fall initiieren . Also hier, lassen Sie uns zuerst die App-Datenquelle
importieren. Datenquelle. Aus einer Datenquelle. Und darin startet Apollo, und von Anfang an müssen
wir auf die Initialisierung der
Datenquelle warten. Jetzt stellt die
Initialisierungsmethode
eine Verbindung zur Postgres-Datenbank her und speichert alle unsere Entitäten als Datenbanktabellen. Und jetzt, bevor wir die API testen, müssen
wir hier etwas korrigieren
und den Kontext untersuchen. Wenn wir also ein
gültiges JWT-Token
haben, schlägt die
Überprüfungsmethode fehl. Und wenn es fehlschlägt, können
wir keine Verbindung
zum GraphQL-Endpunkt herstellen. Und wir werden keine
Resolver verwenden können , für die keine
Authentifizierung erforderlich ist, da die
Methode
einen Fehler auslöst und
unsere gesamte Anwendung beschädigt. Ich werde
also die verifizierte Methode
in einen
Try-Catch-Block einfügen. Auf diese Weise können
wir verhindern, dass Fehler, die
von der Überprüfungsmethode
ausgehen, hier außerhalb
der Kontextmethode ausgelöst werden . Das erste, was
ich tun werde, ist hier eine
Hauptvariable zu erstellen. Dann entferne die
Konstante von hier und kopiere dann all
das oder cat oder das und erstelle den try
catch, catch-Block. Also hier, versuche den Fehler zu finden. Dann Seite hier, im Grunde
Payload mit der Verify-Methode. Und wenn wir hier versagt
haben, werden wir den
Fehler im Catch-Block abfangen. Aber wir werden den
Fehler hier nicht ausgeben,
denn in diesem Fall werden
wir dasselbe
tun
, werden
wir dasselbe
tun was sie bei der
Verifikationsmethode getan haben. Also hier setze ich
die Payload auf nein. Wenn wir nun
das Autorisierungstoken nicht erhalten
haben, schlägt die Überprüfungsmethode
fehl und die Nutzlast wird
auf Nein, Ja gesetzt. Und das autorisierte Eigentum
wird auf falsch gesetzt. Also brauchen wir hier nicht die
if-Anweisung. Und wenn wir
das Autorisierungstoken nicht haben, übergeben
wir
eine leere Zeichenfolge und die Überprüfungsmethode schlägt
sowieso fehl. Der Grund, warum
wir das tun und hier die
if-Anweisung verwendet haben,
ist, dass die
Überprüfungsmethode nur Zeichenketten als Token
akzeptiert hier keine undefinierten
oder Nulltypen akzeptiert. Wenn Sie also
keine Theoretisierung hatten, geben
wir eine Zeichenfolge weiter. Auf diese Weise können wir jetzt
unsere Resolver erreichen , obwohl
wir kein Token erhalten haben. Jetzt speichern wir das
und öffnen das Terminal. Und zum Schluss testen wir
unseren GraphQL-Endpunkt. Lassen Sie mich das hier erweitern
und npm, run, start ausführen. Und bevor wir diesen Befehl ausführen, müssen
wir
etwas ändern , anstatt die angrenzende Datei
zu betteln. Also verwenden wir hier den
Knotenstrich, das Strichmuster, aber dieser Befehl
achtet nicht auf
die Änderungen in
den TypeScript-Dateien. Und wir müssen die
Flaggenuhr wie folgt hinzufügen. In diesem Fall müssen
wir jedoch nur eins und psi hinzufügen. Denn wenn wir hier
zwei und Zeichen verwenden, warten
wir, bis
dieser Befehl
ausgeführt wird , und beenden die Ausführung, und dann führen wir
den Befehl node aus. Aber der Watch-Modus hier endet
nicht, er hat kein n. Ja, deshalb nennen wir
ihn Watch-Modus, ja. Und in diesem Fall werden
wir
diesen Befehl nicht ausführen. Also müssen wir das entfernen
und nur Eins und Sinus verwenden. In diesem Fall werden wir
diese beiden Befehle
gleichzeitig ausführen . Aber das ist sehr gefährlich, denn stellen Sie sich vor ,
wir hätten den Ordner
dist hier nicht und würden den Befehl
node, node ausführen. Und in diesem Fall wird der Befehl
denote kaputt gehen, aber der Kompilierungsbefehl
, der ausgeführt wird. Und es wird nach Änderungen
beim Signieren der TS-Dateien Ausschau halten. Aber wenn der DOS-Befehl den dist-Ordner
generiert. Wir werden feststellen, dass
der Node-Befehl nicht funktioniert und nicht
auf die Änderungen achtet, also wird er das nicht wissen. Jetzt haben wir diesen Ordner
und in diesem Fall bleibt
unsere Anwendung in der Kompilierphase
hängen. Ja. Ich möchte
hier also darauf hinweisen , dass wir den Befehl dash,
dash watch hier
nicht verwenden können . Und wir müssen Node Man in diesem Projekt
wieder verwenden. Stellen Sie also sicher, dass Sie Node Man
erneut in den Dev-Abhängigkeiten installieren . Dann benutze es hier mit dem Node-Befehl ohne
das Wort smoked. Also lass uns das löschen, dann diesen Befehl nehmen
und ihn hier platzieren. Dann löschen wir das
und verwenden Knoten eins. Und mit der E-Flagge und dann TS, dann verstecken sie sich exakt. Dann führen wir den Befehl aus ,
den
Kompilierungsbefehl. Hier, npm, buy-in,
compile, speichere das. Und lassen Sie uns versuchen, unsere App zu
starten. Stimmt. Jetzt. Wir haben keine Fehler
im Zusammenhang mit einer Datenbank erhalten, was bedeutet, dass wir
erfolgreich eine Verbindung
zur Postgres-Datenbank hergestellt haben. Lassen Sie uns nun fortfahren
und den
GraphQL-Endpunkt neben der
Apollo-Sandbox entfernen. Hier haben
wir ein grünes Symbol, das bedeutet dass wir erfolgreich eine Verbindung
zu unserem GraphQL-Endpunkt hergestellt haben. Versuchen wir nun,
hier
einen Benutzer mit den gleichen Anmeldeinformationen zu registrieren einen Benutzer mit den gleichen Anmeldeinformationen und zu prüfen, ob wir Benutzer in der Datenbank
speichern können. Lassen Sie uns diese
Anmeldeabfrage hier ausführen. Und falls nicht, falls
du das nicht aus den vorherigen Videos hattest, kannst
du
hier einfach zum Stammverzeichnis zurückkehren und auf Mutation klicken und dann die Anmeldung wählen. Eigentlich werde ich
die Abfrage für alle Fälle erneut generieren . Fügen wir also die
Anmeldeabfrage oder eine Mutation hinzu. Und die beiden Felder, der Benutzer. Und hier
warten wir nur auf die ID, um sicherzustellen, dass wir
den Benutzer
erfolgreich in der Datenbank gespeichert haben. Jetzt werden wir hier
dieselben Eingaben verwenden. Und von der Anmeldemutation. Ordnung, wir haben
hier das JWT-Token und vor allem
haben wir die ID auf eins gesetzt. Wenn wir also einen neuen Benutzer angemeldet haben, müssen
wir das bekommen. Wir müssen uns ein Bild von zwei machen. Also ändern wir hier
die E-Mail auf Benutzer zwei und den
FirstName user2 und führen dann die Registrierung erneut aus. Und warten wir auf die Antwort. Du musst Ausweis zwei besorgen. Und er würde gehen. Jetzt sind wir sicher, dass wir Benutzer und in
der Datenbank
speichern und dass wir
auch Ergebnisse aus der Datenbank erhalten . Testen wir nun den koreanischen
Chooser, der auflösbar weil die Sinus-n-Mutation ist, dieselbe Logik
hat
wie die Anmeldung. Ja, also lassen Sie uns
den koreanischen Benutzer testen. Und dafür müssen wir
einen Autorisierungsheader senden. Kopieren wir also das JWT-Token. Und hier klicken wir auf das Einstellungssymbol und fügen
die Autorisierungsheader hinzu. Also hier bei Theorization kannst
du einfach anfangen, kannst
du einfach anfangen Autorisierung zu
schreiben und du
bekommst hier einen Vorschlag. Wählen Sie Autorisierung
und fügen Sie das Token ein. Ja, es stellt sicher, dass
der Cookie ausgeschaltet ist. Andernfalls können wir keine Verbindung
zu unserem GraphQL-Endpunkt herstellen. Jetzt speichern wir das. Und lassen Sie uns die
Gradient-Benutzerabfrage ausführen. Also geh hier zurück zur Wurzel. Lassen Sie uns das alles löschen
und auf Abfrage klicken und dann die aktuelle Benutzerabfrage hinzufügen. Und warten wir auf die E-Mail und die Benutzer-ID,
damit wir die Eingabe nicht benötigen. Lassen Sie uns also einfach die
aktuelle Benutzerabfrage ausführen. Und wir sollten die
E-Mail und die ID bekommen. Los geht's. Wir haben den Benutzer dazu gebracht, weil wir das JWT-Token verwenden,
als wir uns als user2 angemeldet haben. Jetzt können wir die
E-Mail und die Benutzer-ID erhalten. Das bedeutet, dass unser
Kontext funktioniert und wir unsere
Payload aus dem Token extrahieren können. Im nächsten Video erstellen
wir nun ein
Bild aus diesem Container.
26. vom postgres zum Bild: Lassen Sie uns nun ein Image erstellen , das diesen
Container für uns ausführt. Also lasst uns
diesen Container verlassen. Und dann lassen Sie uns
das Terminal leeren. Und lassen Sie uns den Befehl docker
commit verwenden , um ein neues Image aus
dem App-Postgres-Container
zu
erstellen dem App-Postgres-Container dieser
Bildnachrichtendatenbank einen Namen und diesen Befehl auszuführen. Und jetzt versuchen wir, dieses Image
auszuführen, bei dem Docker als TI für die
Terminalrichtung ausgeführt wird. Und dann habe ich
den Bildnamen erwähnt. Und bevor wir diesen Befehl ausführen, müssen
wir hier
auch einen Port verfügbar machen, denn wenn wir ein
Image mit Docker Run ausführen, erstellen
wir einen
Container und die Nachricht, unser Datenbank-Image wird
in diesem Container ausgeführt. Wir werden also dieselben Ports verfügbar machen,
die
wir im
App-Postgres-Container verfügbar gemacht haben, indem das Desk-P-Flag an Port
5455 und dann einen Doppelpunkt dann den Port der
Postgres-Datenbank 5432 verwenden. Nun, Sie
haben wahrscheinlich nicht verstanden warum wir hier
dieselben Ports verwenden. Und das liegt daran, dass Sie
denken, dass wir, wenn wir das NSG Add DB-Image ausführen, den App-Postgres-Container tatsächlich ausführen werden. Ja, aber das ist nicht der Fall, denn wenn
wir dieses Image ausführen, werden wir nicht den
App-Postgres-Container ausführen, sondern
das Postgres-Image mit allen Umgebungsvariablen
und allen Konfigurationen. Der
App-Postgres-Container hat also nichts
mit dem MSG AB-DB-Image zu tun . Und jetzt, wenn wir diesen Befehl
ausführen, erhalten
wir einen
Container, der das Postgres-Image auch mit allen Umgebungsvariablen
und Konfigurationen ausführt. Ich hoffe, Sie können jetzt
verstehen, warum
wir dieselben Ports erneut offenlegen müssen. Jedes Mal, wenn wir diesen Befehl
ausführen, erhalten
wir einen zufällig
generierten Container. Denn wenn wir einen Container verlassen
, wird der Container
nicht gelöscht. Aber das wollen wir nicht. Wir wollen, dass jedes Mal, wenn wir einen Container nicht mehr benutzen, dieser Container gespendet werden
muss. Und das können wir
automatisch tun,
indem wir dem Befehl rand,
dem RM-Befehl
, eine neue Flagge hinzufügen. Und jetzt können wir diesen Befehl ausführen. Und wenn wir mit der Arbeit
mit dem Container fertig sind, heißt das, wenn wir den Container verlassen
, wird
der Container gelöscht
und wir erhalten keine zufällig generierten
Container in unserem Docker-Repository. Lassen Sie uns nun
diesen Befehl ausführen und
warten ,
bis die Datenbankverbindung hergestellt ist. In Ordnung, wir haben unsere
Datenbank am Laufen. Gehen wir zurück zu unserem
Projekt und dem Terminal. Lassen Sie uns npm ausführen. Lauf, fang an. Stellen Sie sicher, dass Sie immer noch
die 5455 Kugeln hier haben. Lassen Sie uns den Befehl ausführen. Wir können sehen, dass wir keine Datenbankfehler
bekommen haben. Jetzt habe ich hier einen doppelten Schrägstrich
für den GraphQL-Endpunkt, und das liegt daran dass das hier
nicht geändert wurde
und sagen wir die Datei main.js. Also werde ich das jetzt machen
und die Datei main.js speichern. Warte auf das Reload und dann musst
du das richtige Jahr ermitteln. Navigiere nun zu dieser URL. Und in der
Apollo-Sandbox ist das die API. Sie können also
hier sehen, dass ich
die Validierung für das
Anmelde-Repository getestet habe. Wenn wir uns also
mit derselben E-Mail angemeldet
haben, erhalten wir
eine fehlerhafte Anforderungsfehlermeldung besagt, dass der Benutzer
bereits existiert. Wir wissen also, dass dieser Teil des
Anmelderesolvers funktioniert. Jetzt melden wir uns wie gewohnt an. Und hier, FirstName
user1 und run sign up. Und wir sollten einen Benutzer bekommen,
dessen ID auf eins gesetzt ist. Stimmt es? Wir haben die ID und wir
haben das JWT-Token.
27. Das Raumschema definieren: Jetzt ist es an der Zeit, mit der
Arbeit am Zimmerservice zu beginnen. Und wie zuvor beginnen
wir mit dem Schema, das die DO-Datei grafisch darstellt. Aber ich werde
das GraphQL-Schema des Zimmerservice nicht in
das schematische Diagramm schreiben Zimmerservice nicht in
das .
Gail Fail ist, wissen
Sie, es ist immer
eine gute Praxis Dateien
in kleine Teile aufzuteilen, besonders wenn Sie eine große Datei
haben. Das
werden wir also hier tun. Beginnen wir damit,
einen neuen Ordner im
Quellordner zu erstellen und ihm einen Namen zu geben. Dröhnt. Und dann haben
wir hier die Räume oder den Raum, den GraphQL. Und dann schreiben
wir hier unser GraphQL-Schema, das sich auf den Zimmerservice
bezieht. Und dann werden wir dasselbe für
den Off-Service tun . Und wir werden die, die,
die groben DO-Dateien lernen die groben DO-Dateien und dann all das automatisch hinzufügen,
automatisch in
die TO-Datei des Schema-Punktdiagramms. Lassen Sie uns hier beginnen, beginnen wir mit der Definition
des Zimmertyps. Lassen Sie uns also einen
Typ erstellen und ihm einen Namen geben. Zimmer. Und ROM wird
natürlich eine ID vom Typ int und sie ist
erforderlich und eine Reihe von Benutzern enthalten. Also müssen wir den Benutzertyp verwenden. Und wie Sie hier sehen können, habe ich keinen Fehler,
da wir
den Benutzertyp bereits verwendet oder
diese hier als Typ deklariert haben . Und wie ich bereits sagte, werden
wir
die beiden Dateien zusammenführen,
den Erdgraphen
Gill und ihr eigenes GraphQL innerhalb des Schemas,
dieser GraphQL-Datei. Wir werden also Zugriff auf
den Benutzertyp haben. Definieren wir hier also
den Raum mit dem Benutzer und den Nachrichten. Dann die Nachrichten,
es wird
ein Array von Nachrichtenobjekten sein . Und das müssen wir oben
definieren. Hier. Deklarieren Sie einen anderen Typ,
nennen Sie ihn Nachricht. Und die Nachricht wird
ein Formularfeld haben. Und es ist die ID des Benutzers. So können wir wissen, wer
die Nachricht gesendet hat und
welchen Inhalt die Nachrichten haben. Und dieser ist vom Typ String. Um nun eine Nachricht zu senden, benötigen
wir die Nachricht selbst. Es bedeutet den Inhalt. Und wir brauchen auch das Bromid D und speichern dann
die Nachricht im Raum. Die Nachricht, die
Nachricht ist ein Array. Dann haben alle Benutzer
im Array des
Benutzers Zugriff
auf diese Nachricht. Wenn wir hier also zwei Benutzer haben, Benutzer a und Benutzer B, wird
die Nachricht von Benutzer a an den Benutzer B empfangen Und natürlich haben beide Benutzer Zugriff auf dieselbe Nachricht. Erstellen wir also hier eine
Eingabe, geben Sie sie ein und benennen Sie sie,
senden Sie die Nachrichteneingabe. Und wir benötigen die Nachricht
vom Typ string und wir benötigen die
Raum-ID vom Typ int. Lassen Sie uns nun die Mutation erstellen , die diese Eingabe akzeptiert. Also hier Typmutation, die erste Mutation ist die
Sandnachrichten-Mutation. Und hier, so ist MSE,
steht für Message. Und hier
akzeptieren wir eine Eingabe. Sie können diese Variable
beliebig benennen. Ich nenne es gerne Input. Also hier ist diese Eingabe
vom Typ gesendete Nachrichteneingabe. Und wir werden die Regel
zurückbringen. Lassen Sie uns das jetzt speichern. Natürlich sind wir noch nicht fertig, aber ich möchte hier die
orthografische DO-Datei erstellen. Ja, also lass uns
eine neue Datei in
dem Ordner erstellen und
sie Earth Dot GraphQL nennen. Und hier werden wir das alles in
das GraphQL-Schema
kopieren und sicherstellen, dass es ausgeschnitten wird. Und dann speichere diese Datei und kehre zum Autogramm Gill und füge das alles hier ein. Jetzt sollten wir das Schema hier nicht
hinzufügen, da dies unseren GraphQL-Endpunkt beschädigen würde,
da wir es innerhalb der
GraphQL-Datei mit
dem Schemapunkt
definieren automatisch innerhalb der
GraphQL-Datei mit
dem Schemapunkt
definieren werden. Also lass es uns entfernen. Und safe stellt auch
sicher, dass in allen Subgraph-Kills fehlschlägt. Wir haben eine Mutation
und eine Abfrage und stellen sicher, dass beide groß geschrieben sind. Also auch im falschen
GraphQL befindet sich eine Mutation. Und dann werden wir
die Abfrage erstellen und sie
so benennen, wie wir es in Earth GraphQL getan haben
. Und Sie können
den Namen hier ändern. Ja, weil es nicht so ist, es geht nicht um den Namen, sondern um den Spot, der den gleichen Namen hat. Du kannst das also so haben. Und in diesem Fall müssen
Sie
die Raum-GraphQL-Notation durch
ein kleingeschriebenes m ändern . Aber das will ich nicht. Ich möchte ein M in Großbuchstaben, also ändere ich das
wie zuvor, und das war's. Im nächsten Video werden wir die Logik
schreiben, die das Zusammenführen dieser beiden Dateien
innerhalb des automatische Zusammenführen dieser beiden Dateien
innerhalb des Schema-Punkts
GraphQL übernimmt.
28. Schemata automatisch generieren und zusammenführen: Lassen Sie uns nun die Datei
im Quellordner erstellen und sie benennen, das Schema
generieren. der T-Seite werden wir
hier die Logik schreiben
, die
alle Untergraphen Ihrer Schemas
in der GraphQL-Datei mit dem
Schemapunkt zusammenführt werden wir
hier die Logik schreiben
, die
alle Untergraphen Ihrer Schemas
in der GraphQL-Datei mit dem
Schemapunkt zusammenführt alle Untergraphen Ihrer Schemas
in der . Das erste, was wir tun
müssen, ist,
alle Dateien, die mit
einem Punkt GraphQL enden, aus
dem Quellordner zu importieren alle Dateien, die mit
einem Punkt GraphQL enden . Und dafür müssen wir ein neues Paket
installieren. Öffnen Sie also Ihr Terminal
und führen Sie den Befehl npm aus, installieren Sie das Paket globe und installieren Sie auch die
Typen für dieses Paket. Und führe diesen Befehl aus. In Ordnung, jetzt schließen wir das
Terminal und gehen zurück hierher. Und beginnen wir mit dem Import
des Globe-Pakets. Also hier, Globus von Glow. Globe ist also eigentlich eine
Funktion, die wir aufrufen
und den Pfad
unserer Dateien angeben können und den Pfad
unserer Dateien angeben , nach denen wir suchen
möchten. Für uns suchen wir
also
im Quellordner und in jedem
Ordner
und dann in jeder Datei, die mit GraphQL
endet. Und dann müssen wir hier
einen Callback definieren , der einen Fehler und Dateien
akzeptiert. Wenn wir also einen Fehler haben, geben wir einen Fehler aus,
lösen einen neuen Fehler aus oder werfen
einfach den, lass uns weitermachen. Als erstes müssen wir
die vorhandene GraphQL-Datei
mit
dem Schema dot mit der Methode unlink
aus dem FS Beckett löschen die vorhandene GraphQL-Datei
mit
dem Schema dot . Also aus den Dateisystempaketen. Das ist also wichtig. Die Abkopplung von nicht nur uns, sondern fs verspricht
hier Apotheker. Und wir müssen auf
einen Link warten und dann
den Schemapunkt GraphQL löschen. In Ordnung, jetzt deklarieren wir eine Variable und nennen
sie Types Array. Force wird vom Typ Array
sein und Zeichenketten enthalten. Also wird er alle
Schemas als Zeichenketten speichern. Und das wird in ein leeres Array initiiert
. Und dann hier, lassen Sie uns alle Dateien
lesen und sie als Zeichenketten
in das Typ-Array einfügen. Dafür müssen wir die Dateien
mit der Methode for each durchgehen. Nehmen Sie hier jede
Datei und extrahieren das Schema aus der Datei eine andere Methode aus
dem Dateisystempaket
verwenden, nämlich die Lese-Dateisynchronisierung. Also werden wir eigentlich eine Datei
lesen. Und hier geben wir
die Datei hier weiter. Diese Datei ist also ein Pfad oder nur der Name der Datei, hier ist
der Pfad der Datei. Und das bedeutet,
es hier in den Dateipfad zu ändern. Dateipfad, hier drin, Dateipfad. Und hier müssen wir
die Kodierung definieren, weil wir das
Schema als Zeichenfolge extrahieren müssen. Lassen Sie uns also in eine
UTF-Acht codieren und dann
das Schema nehmen und es
in das Typ-Array verschieben. Also gibt ein Array ein, pusht das Schema. Nachdem wir das getan haben, müssen
wir eine weitere
Variable erstellen und
ihr den Namen type deaths geben. Und hier müssen wir
alle Entwürfe Ihrer Schemas zusammenführen. Also alle Zeichenketten innerhalb des
Typ-Arrays in einer Datei. Und dafür benötigen wir das Merge-Tool aus den
GraphQL-Tool-Paketen. Gehen wir also zu
unserem Terminal und stylen den GraphQL in Richtung Beggars NPM. Also bei GraphQL Dash Tools und dann Slush Merge. In Ordnung, lass uns das
Terminal schließen und hierher zurückkehren. Und lassen Sie uns zuerst
das Merge-Tool aus
der unteren Spezifikation importieren . Also importiere, importiere Nourish Type Devs aus GraphQL. Dann Tools als Merch. Und wir werden diese
Methode anwenden. Kopieren wir also den Namen
hier und fügen ihn hier und zitieren ihn dann. Wir werden die
Typumfrage bestehen. Nun, diese Methode
generiert eine Dokumentnotiz, aber um
etwas
an eine Datei anzuhängen, müssen
wir eine Zeichenfolge generieren. Dafür benötigen wir also
ein anderes Tool von GraphQL. Importieren Sie also aus GraphQL
eine andere Methode namens print. Die Vorderseite nimmt also die oberste Typedef und
wird in eine Zeichenfolge umgewandelt. Also sagen wir hier, das hat das
in die Pflanzenmethoden aufgenommen. Nun der Typ, dieser
ist vom Typ String. Lassen Sie uns also
die Zeichenfolge in der GraphQL-Datei mit
dem Schemapunkt anhängen, indem die Methode append
aus dem FS-Gepäck verwenden. Stellen Sie also sicher, dass Sie das hier importieren. Und jetzt benutzen wir es und erwähnen den
Schemapunkt GraphQL. Und hier
müssen wir die Typen hinzufügen
, die wir an die Gil-Datei
mit dem schematischen
Diagramm anhängen können . Und diese Funktion
akzeptiert auch einen Rückruf. Definieren wir also die Funktion
und wir akzeptieren einen Fehler. Und wenn wir dann irgendwelche Fehler haben, werden
wir das besser
werfen. In Ordnung, jetzt, wenn wir fertig sind, möchte
ich
eine Bestätigungsnachricht auf
meiner Site, meinem Terminal, sehen . Also werde ich die vom GraphQL-Schema
generierte Nachricht
auf der Konsole protokollieren . Oder vielleicht verwenden wir
die Punktinformationen der Konsole. Und bevor wir
diese GraphQL-Datei
an das Schema anhängen ,
müssen wir diese Datei erstellen,
denn hier sind wir. Wir werden
den schema.gov-Kill löschen. Um eine Datei zu erstellen, müssen
wir also die
richtige Dateisynchronisierungsmethode
aus den FS-Paketen verwenden . Sie auch hier
sicher, dass Sie das
aus dem FSLR-Paket importieren . Hier fügen wir auch
den Schemapunkt GraphQL hinzu. Das ist also ein Weg für
die Schuld am Schemagraphen. Und wenn wir
nur den Namen erwähnen, wenden
wir diese Methode an
, dass der Schemagraph Gill tatsächlich
im Stammverzeichnis dieses Projekts existiert. Also hier, Schemagraph. Und ich möchte an diese Datei
eine Meldung
anhängen , die besagt, dass dies ein generiertes Schema
ist. Dann sagen wir hier, tu es nicht. Stimmt es? Lassen Sie uns jetzt
auch eine neue Zeile erstellen. Und hier müssen wir
ein Flag an einem Objekt und
innerhalb dieser div-ähnlichen Option hinzufügen . Und weil wir etwas an diese Datei
anhängen werden, werden
wir das a-Flag für das
Anhängen verwenden. Und weil wir hier das Schema
GF q five
löschen, müssen
wir das Pluszeichen verwenden um die Datei zu erstellen,
falls sie nicht existiert. Lassen Sie mich jetzt den Code hier anpassen. Und fügen wir hier auch
eine weitere Zeile hinzu. Backslash n für eine neue Zeile. Jetzt sind wir mit der Erstellung
dieses Skripts fertig und
werden
die Globe-Funktion
als Befehl aus der Datei
package.json ausführen die Globe-Funktion
als . müssen wir tun, bevor wir die Typen
für unser GraphQL-Schema erzwingen. Also vor diesem Befehl werden
wir
Note ausführen und dann auf
den Ordner dist verweisen und auf source
generate schema that Z, S. Und hier im compilierbefehl werden
wir unseren Code kompilieren und dann werden wir den Befehl degenerate
ausführen. Also hier, npm, run generate
two und science auch hier. Und dann speichern. Öffnen wir nun das Terminal
und führen degenerate come out aus. Und natürlich müssen wir zuerst den Code
kompilieren. Lassen Sie uns also TSE ausführen. Und dann lassen Sie uns
den npm run generate ausführen. Und los geht's, wir haben die
generierte Nachricht des GraphQL-Schemas. Und jetzt müssen wir
das Schema Graph
Girl analysieren und all
diese generierten
TypeScript-Typen dort hinzufügen . Lassen Sie uns nun das
Schema dieser Golfausrüstung überprüfen. Und los geht's. Wir haben unser generiertes Schema. Wir haben unsere Typen und Eingaben. Und hier die Mutation, du kannst sehen, dass wir die Off-Mutationen
haben, die Anmeldung und Anmeldung. Und wir haben die Mutation, die Mutation zum Senden von Nachrichten, automatisch
dem Mutationstyp hinzugefügt wird. Und natürlich
haben wir nur eine Abfrage, die aktuelle Benutzerabfrage. Und Sie können auch hier sehen, dass wir das Schema auch hier automatisch
generiert haben. Ja. Und denk dran, als ich gesagt habe, dass wir hier
Zugriff auf den Benutzer bekommen, falls du das nicht verstanden hast. Ich meine, wenn wir
das Schema, das Schema,
das GraphQL generieren , werden wir alle Typen in einer Datei
haben. Wir werden also
auch Zugriff auf den Benutzertyp erhalten. Ja. Es ist also in Ordnung, die Benutzertypen in der
Room Dot GraphQL-Datei zu verwenden, obwohl wir sie hier nicht
deklariert haben. Jetzt, im nächsten Video, werden
wir
die Raumresolver erstellen. Und dann werden
wir sie innerhalb des
Moduls, der ts-Datei
, mit den Resolvern zusammenführen.
29. Erstellen des room: nun im Ordner rooms Lassen Sie uns nun im Ordner rooms eine neue
Datei erstellen und sie von der Seite des Resolvers aus
benennen . Lassen Sie uns eine Konstante mit
einem Namen exportieren, room resolvers. Und diese Konstante wird
ein Objekt des Typs sein. Ergebnis sieht aus. Es ist wichtig, dass aus
unseren generierten Typen. Also ein Portresolver
von geh raus wenn level und wähle diese
integrierten Ordner und wähle dann die Resolver aus. Die Datei mit den Dash-Typen befindet sich
jetzt hier. Wir werden die Mutation
definieren. Und wir haben nur eine Mutation, nämlich die Mutation „
Nachricht senden“. Da wir die Entität nicht
erstellt
haben, senden wir nun manuell erstellte Daten zurück
. Definieren wir hier zunächst
die Sandnachrichtenstation. Und wir haben das Elternteil, haben den Input und den Kontext. In Ordnung? Jetzt können nur autorisierte
Benutzer eine Nachricht einrichten. Lassen Sie uns also überprüfen, ob wir
einen autorisierten Benutzer haben , indem die Kontexte
überprüfen, die die Eigenschaft
autorisiert haben. Und wenn wir hier Gewalt haben, geben wir
einen neuen GraphQL-Fehler aus
und stellen sicher,
dass wir ihn einen neuen GraphQL-Fehler aus GraphQL importieren. Und dann schicke ich eine
unautorisierte Methode zurück oder ich sende eine Nachricht. Also eine autorisierte Nachricht, und das ist eine Erweiterung. Also hier Spannungen. Und wir werden den
unautorisierten Mantel hierher schicken. Und für Rised. Und jetzt schicken wir ein Raumobjekt
zurück. Lassen Sie mich also überprüfen, wie
das Objekt aussieht. Wir haben also eine ID,
Benutzernachrichten. Also fügen wir das hinzu. Diese ganze Rendite ist eine. Und für die Benutzer müssen
wir ein
Array von Benutzerobjekten erstellen, aber wir können einfach ein leeres Array
und auch das Nachrichten-Array
zurücksenden . Aber das ist ein Sandsack, nur eine Nachricht hier. Lassen Sie mich überprüfen, wie die
Nachricht aussieht. Wir haben die
Felder from und content from und object from, sagen
wir eins und die
Inhaltstestnachricht. In Ordnung, jetzt speichern wir
diese Resolver-Datei. Oder lassen Sie uns die Eingabe für
das Nachrichtenobjekt
verwenden , um sicherzustellen, dass wir die Client-Daten
sein können. Für den Inhalt gebe
ich die eingegebene Punktnachricht zurück . Und hier haben wir die Nachricht, entweder eine Zeichenfolge oder eine undefinierte weil wir hier kein
Ausrufezeichen hinzugefügt haben. Also lass uns das machen. Speichern. Natürlich müssen wir das Schema erneut
generieren. Also lasst uns NPM ausführen, npm
generieren, schon dabei gewesen, oder? In Ordnung, jetzt haben wir
das Schema und die Typen generiert. Gehen wir also zurück zu den normalen Servern und wir können sehen, dass
der Fehler verschwunden ist. Wir können das
Fragezeichen von hier aus entfernen. Und die Nachricht hat jetzt
nur noch den Typ Zeichenfolge. Und hier in der ID schicken
wir
die eingegebene Raum-ID zurück. Weil das Zimmer verärgert ist. Ja, speichern wir das. Und im nächsten Video werden
wir zusammenführen. Der Autor ist fertig und
der Raum löst sich
hier in der Datei
module.js auf und
testet dann den GraphQL-Endpunkt.
30. Resolver zusammenführen: Um nun die Resolver
zusammenzuführen, benötigen
wir ein weiteres Tool von GraphQL, um Pakete mit einem Schrägstrich
zusammenzuführen. Also
lassen Sie uns oben in dieser Datei das neue Tool importieren, nährende Resolver von GraphQL,
Dash-Tools, die nach Paket riechen. Und wir müssen auch den Raumresolver
importieren. Also hier Regelresolver aus dem Raumordner und aus
der Raumauflösungsdatei. In Ordnung, jetzt, unten hier, verwenden
wir
die Funktion oder
das Tool zum Zusammenführen von Resolvern innerhalb
der App-Modulklasse. Lassen Sie mich das also ausschneiden und dann
die Merge-Resolver
als Funktion verwenden . Und diese Funktion akzeptiert
eine Reihe von Ergebnissen. Also füge ich ein Array hinzu und füge
dann das Büro des
Autors hier ein. Und Sie können sehen, dass der
Fehler verschwunden ist, da die Händlerresolver den Resolver-Typ
zurückgeben. Und hier können wir so viele Resolver
hinzufügen wie wir wollen, weil
wir ein Array akzeptieren. Fügen wir also auch die
Raumresolver hinzu und speichern wir diese Datei. Lassen Sie uns nun überprüfen, ob
wir
unseren PI immer noch ausführen können und ob wir
nichts kaputt gemacht haben. Öffnen wir also das Terminal und
führen den Befehl npm start aus. Zuerst. Stellen wir sicher, dass
wir eine laufende Datenbank haben. Also Docker zu verwenden, das ist eine. Dann dieser Strich oder M für das
Entfernen des Containers, sobald
wir mit der Arbeit damit fertig sind, dann TI für Terminal
und Richtung und dann benenne unsere Nachricht DB-Image. Und vergiss nicht,
den Port 5455 und den 5432 freizulegen. Und lassen Sie uns diesen Befehl ausführen. Stimmt. Jetzt. Lass uns hierher zurückkehren
und npm start ausführen. Dieser Befehl
generiert zuerst das Schema
und dann die Typen und dann einen, die API. Aber zuerst kompilieren
wir
den Code und führen dann
den Befehl incinerate aus und dann unsere API. Wir haben hier ein
GraphQL-Schema generiert. Wir haben auch die Typen. Und jetzt sollten wir
die Erfolgsmeldung erhalten. Öffnen wir nun die Sandbox. Sandbox und melden wir uns zuerst an. Also hier habe ich die
Anmeldemutation, ich habe alle Eingaben. Versuchen wir, uns anzumelden. Wie Sie hier sehen können, haben
wir die ID. Und das liegt daran, dass wir jedes
Mal, wenn wir
die Datenbank schließen und erneut ausführen, eine neue Datenbank erhalten. Ja. Also nehmen wir jetzt das
JWT-Token und gehen zu den Einstellungen und fügen dort den
Autorisierungsheader hinzu. Speichern Sie hier
die Autorisierung oder das JWT-Token. Und lassen Sie uns jetzt die Mutation für
gesendete Nachrichten ausführen. Lassen Sie mich das alles klären. Und gehen wir zurück
zur Mutation. Und Sandnachricht oder das Prädation „
Nachricht senden“ überhaupt. Die Ergebnisse sind die Felder. Hier. Wir haben keine Benutzer, aber wir werden die ID dort hinzufügen. Und wir werden das von,
aus der Nachricht
und dem Inhalt herausfinden. Nun zur Eingabe Lassen Sie uns
zuerst alles löschen und dann die
Nachricht und die Raum-ID hinzufügen. Also die Botschaft hier,
das ist die Botschaft. Und die Zimmernummer.
Sagen wir, nun, natürlich haben wir keine
Raum-ID-Tabelle, stellen Sie die Datenbank ein. Also lass uns eine Nachricht senden. Und wir sollten zurückgehen. Und Objekt der Raum-ID mit
id1-Benutzern ein leeres Array. Und wir haben hier
unsere Nachricht mit der
Nachrichtentestnachricht direkt hier. Jetzt funktioniert alles. Wir müssen noch
die Raum-Entität erstellen und
die Raum-Resolver fertigstellen.
31. die room erstellen: Lassen Sie uns nun
die Raum-Entität erstellen. also im Ordner Räume Erstellen Sie also im Ordner Räume einen weiteren Ordner
und nennen Sie ihn Regel. Und dann hier, erstelle einen weiteren Ordner
und nenne ihn Entität. Und dann lassen Sie uns endlich
die Raumpunkt-Entität erstellen , ja. Beginnen wir also mit Export und der Definition einer Klasse
mit dem Namen Rome. Dann müssen wir die Entität verwenden, das Zeichen von Band around, Entität vom Typ oder N
unterstützen und es für diese Klasse verwenden. Jetzt hier drinnen beginnen
wir mit der ID. Und wieder müssen wir
die primär generierte Spalte importieren , das Zeichen für die ID. Und hier ist es seltsam
, dass der Charakter, dann brauchen wir eine Reihe von Benutzern. Lassen Sie uns hier Benutzer hinzufügen und es als eine Reihe von Benutzern
definieren. Und wir müssen die
Benutzerentität vom Benutzer importieren, diese Entität Punkt ds. Also hier
geht der Benutzer von einer Ebene,
zwei Ebenen und drei Ebenen zurück . Seite Der Benutzerordner aus und
traurig. Wählen Sie das Innere
des Entitätsordners aus. Wählen Sie den Benutzer,
diese Entitätsdatei. Jetzt sind die Benutzer
eine, ist eine Spalte, also müssen wir
eine Farbe und das Zeichen
aus Type Around importieren . Also hier, Carlin, und benutze es hier. Für die Spalte Benutzer erstellen
wir nun eine Viele-zu-Viele-Beziehung mit der Benutzerentität. Und dafür müssen wir das Viele-zu-Viele-Zeichen
importieren, den Charakter vom
Band herumtragen und ihn hier bei vielen, vielen
verwenden. Jetzt müssen wir den
Typ der Beziehung definieren, und in unserem Fall ist
es die Benutzerentität. Hier müssen wir also eine Funktion
hinzufügen und die
Benutzerentität als Typ
finden oder zurückgeben. Damit das funktioniert, müssen
wir jetzt einen weiteren Charakter hinzufügen, die Join-Tabelle zu
Garreta und sie hier verwenden. Also die Join-Tabelle, der Charakter nimmt
die IDs des Raums und der Benutzerentitäten und
speichert sie in einer Tabelle. Jetzt müssen wir
die Viele-zu-Viele-Beziehung nur auf
einer Seite der Beziehung verwenden . Und das nennt man eine
unidirektionale Beziehung. Wenn Sie eine
bidirektionale Beziehung erstellen möchten, können
Sie zur Benutzerentität wechseln. Und hier kannst du eine weitere Spalte
erstellen und sie Regel nennen und das
Viele-zu-Viele-Zeichen verwenden. Jetzt haben wir
die Raum-Entität. Und das sollte ein Array sein. Und verwende das Viele-zu-Viele-Zeichen
, um hier zu charakterisieren und den Typ zu definieren. Also hier
holen wir uns die Raum-Entität. Und auch hier müssen wir eine weitere Funktion
hinzufügen wir
die Eigenschaft zurückgeben müssen , die die
andere Seite der Beziehung besitzt. In unserem Fall beziehen
wir also neben dem Raumobjekt neben dem Raumobjekt
die andere Seite
der Beziehung vom Eigentum
des Benutzers. Und wir sollten
dasselbe innerhalb der Raumeinheit tun. Aber für die
Verknüpfungstabelle, das Zeichen, sollten
wir es hier nur auf einer
Seite der Beziehung verwenden. Lassen Sie uns hier
dasselbe tun, nur ein Beispiel. Also hier der Benutzer
und dann der Return, Benutzer Punkt room
zurückgegeben, weil die Raumeigenschaft die andere Seite
der Relation
besitzt. Und sollten, es sollten
Zimmer sein, nicht Zimmer hier. Aber auch hier ist es nur ein Beispiel. Ja, wir werden hier nicht
die bidirektionale
Beziehung verwenden . Wir brauchen nur
das gewerkschaftliche Verhältnis,
unidirektionale Beziehungen. Lassen Sie uns das untersuchen und speichern, zur Benutzerentität zurückkehren
und all das entfernen. Und stellen Sie sicher, dass Sie
alle Eingabeanweisungen der
Regelentität löschen und diese schließen. Jetzt sind wir immer noch nicht
fertig, da die Postgres-Datenbank
keine Arrays unterstützt. Ja. Und dafür müssen
wir einen sehr
einzigartigen JSON-Typ verwenden,
nämlich den JSON B. Jetzt sind die Datentypen
Jason und Jason B fast identisch. Der Hauptunterschied besteht
darin, dass JSON-Daten als exakte Kopie
des JSON-Eingabetextes
gespeichert werden. Was ist JSONB speichert
Daten in einem Decomposer. Binär ist dafür
keine Zeichenfolge. Ja, wie JSON, aber
als Binärcode. Und dafür steht die
Binärdatei. Unsere ADB steht für, sie steht für eine Binärdatei. Nun, das ist die
einzige Möglichkeit,
mit Arrays mit Postgres zu arbeiten . Also müssen wir das tun. Sie müssen JSON v verwenden,
anstatt einfache Arrays
sind einfach JSON. Jetzt füge ich hier eine
Option hinzu und sage nullable,
false, weil ich hier
keinen Nullwert für
die Benutzereigenschaft erhalten
möchte . In Ordnung. Jetzt
brauchen wir noch die Nachrichten. Also fügen wir es hier hinzu. Und es wird vom Typ Nachricht
sein. Und das können wir
aus den generierten Typen importieren. Stellen Sie sicher, dass Sie dies ändern. Gehen Sie zwei Ebenen raus, denken Sie an drei Ebenen. Und hier,
machen wir daraus ein Array. Wenn Sie den Mauszeiger über diesen Typ
bewegen, können Sie feststellen, dass
wir den Inhalt
und das Formular als
erforderliche Eigenschaften haben . Und wir haben hier den Typnamen, der nicht erforderlich ist. Daher können wir hier
den Nachrichtentyp verwenden. Ja, das ist nicht das Problem. Jetzt. Definieren wir hier eine Spalte. Eine Kolumne. Und wir müssen
den angrenzenden Anfang verwenden , weil
wir das einfache Löschen nicht verwenden können. Und ich möchte, dass es nicht auf Null gesetzt
werden kann. Also füge ich
Nullable hinzu, das gleich Falsch ist. Und sicher.
32. Räume erstellen und aktualisieren: nun im Raumordner Lassen Sie uns nun im Raumordner eine weitere
Datei erstellen und
sie Room Dot Service nennen , das ja. Hier exportieren wir einen
Klassenraumservice und erstellen so den Konstruktor. Und hier erstellen wir
den Raum, unser Repository. Und es wird vom Typ
Repository sein. Das können wir
vom Band importieren. Importiere also das Repository
von type around. Hier müssen wir
die Raum-Entität
als Argument hinzufügen , Rom. Und das ist wichtig
, das von der Entität. Definieren wir nun die Methode,
die einen Raum für uns erstellt. Also hier, acing, schaffe Raum. Und diese Methode akzeptiert
ein Argument von Teilnehmern, bei dem es sich um eine Reihe von Benutzern handelt. Also hier, Array-Benutzer, und das ist die Benutzerentität. Also müssen wir
es von hier importieren, Port-Benutzer von zwei Ebenen
verlassen und dann den Oath-Ordner
auswählen. Und von dort aus, der Benutzerordner, die Entität und die
Benutzerentitätsdatei, nicht nur die Teilnehmer hier, wir benötigen auch die Nachricht. Denn wenn
wir einen Raum erstellen,
wenn der Benutzer zum ersten Mal versucht , eine Nachricht an einen anderen
Benutzer zu
senden. Also hier wird
die Nachricht vom Typ Nachricht sein. Und wieder werden wir
das aus diesen generierten Typen importieren . Also hier, Nachricht von außen
auf eine Ebene
importieren, zwei Ebenen. Und dann am Samstag
generierter Ordner, wählen Sie die Datei mit den Resolver-Typen aus. Jetzt erstellen wir einen Raum mit
dem Repository-Repository und
in dem Methoden erstellt werden. Jetzt ist es wahr, außer Benutzern. Also die Benutzer oder
die Teilnehmer und akzeptiert auch
das Nachrichtenarray. Da wir
also einen neuen Raum erstellen werden, fügen
wir die Nachricht
manuell zu einem Array hinzu. Also werden wir ein
Array mit einer Nachricht bekommen. Ordnung, jetzt
müssen wir ein Gewicht zurückgeben, das Punkte Raum-Repository, das das Raumdokument
speichert und weitergibt. Jetzt scheint es, dass
sie
hier im Repository einen Tippfehler haben . Also lass mich das reparieren. Und ich werde die
Mehrfachauswahl verwenden und das vielleicht
in ein Repository ändern, oder? Jetzt lasst uns sparen. Und jetzt müssen wir uns mit
dem Fall befassen, in dem wir eine
Botschaft an eine bestimmte Regel senden möchten. Lassen Sie uns hier
eine andere Methode erstellen. Es wird wieder asynchron sein und den Namen wählen, Nachrichten
hinzufügen, um sie zu bearbeiten. Sie können den Namen der
Sandnachricht wählen. Aber ich möchte
hier ganz klar sagen, dass wir eine Nachricht an einen Raum
senden werden, und hier werden wir einen Raum
erstellen. Ja. Um dies zu tun, um eine Nachricht an einen bestimmten Raum
zu senden, benötigen
wir
natürlich die Raum-ID vom Typ Nummer. Und wir brauchen die Art
der Nachricht, Message. Hier, Nachricht. Und jetzt steht er auf der Seite. Wir werden den Query
Builder verwenden. Und das liegt daran, dass wir uns mit Jason be Arrays
auseinandersetzen müssen. Wenn Sie sich also erinnern können, definieren
wir die
Nachrichtenspalte als JSON B. Und weil wir hier haben, wird
das Array-Zeichen von TypeScript vom Typ Jason be array sein. Die einzige Möglichkeit, mit
Jason-Be-Arrays
umzugehen , besteht darin,
die erstellte Abfrage zu verwenden. Definieren wir nun
Query Builder hier. Dieser Punkt ist eindeutig
unser eigenes Repository. Erstellen Sie Query Builder. Und hier erstellen wir einen Weight Query Builder. Aktualisieren. Es geht, wir werden
einen vorhandenen Raum aktualisieren und dann die neue Nachricht
zum Nachrichten-Array hinzufügen. Also aktualisieren, wir benötigen hier die
Raum-Entität als Typ und die Eigenschaft, die innerhalb eines Objekts aktualisiert wird
. Also werden wir die
Nachrichten aktualisieren und wir werden eine
sehr spezifische und einzigartige Methode verwenden ,
um diese Eigenschaft zu aktualisieren. Also werden wir eine Methode oder eine Funktion
verwenden , um
eine Abfrage zurückzugeben. In dieser Abfrage wird Eigenschaftsname
der Nachricht angegeben
und dann 2 Balken hier hinzugefügt. Und ich werde
das gleich erklären. Ja. Und jetzt fügen wir
Anführungszeichen hinzu. Und hier werden wir die Nachrichten
als JSON-String
hinzufügen. Also werden wir die
JSON-Stringify-Methode verwenden und die Nachricht übergeben. Und dann denk daran, dass wir als Jason Beat Nachrichten hinzufügen müssen. Also werden wir das in
Jason V
konvertieren, indem wir zwei Spalten hinzufügen. Und dann, richtig,
Jason, sei so. Diese ganze Zeichenfolge
ist also eine Postgres-Abfrage. Und wenn wir die beiden
Spalten und den Jason
so hinzufügen , wird das
von Postgres als Abfrage analysiert. Und Postgres kümmert sich um die
Konvertierung dieser Zeichenfolge,
dieser JSON-Zeichenfolge,
zweier angrenzender Beats. Und die 2 Balken hier bedeuten
, dass wir diese JSON-B-Zeichenfolge und
an die Nachrichteneigenschaft
anhängen werden. nun den Query
Builder verwenden, um eine Abfrage mit
der Aktualisierungsmethode
hinzuzufügen, müssen
wir sie
als von einer Methode zurückgeben. Okay, lassen Sie mich
diesen Code anpassen und
mit dem Query Builder fortfahren. Wir werden also einen Raum aktualisieren, aber wir müssen
den Raum identifizieren , den
wir aktualisieren werden. Und dafür
verwenden wir die Where-Methode. Und diese Methode fügt dem eine
Where-Bedingung Abfrage-Generator
eine
Where-Bedingung hinzu und
erstellt die Where-Bedingung. Wir fügen hier eine Zeichenfolge hinzu
und sagen, dass wir einen Raum
aktualisieren werden , in dem die
ID der Variablen ID entspricht, und wir können
diese Variable in einem anderen
Argument dieser Methode definieren . Und
definieren Sie in einem Objekt die ID, und es wird
auf die Raum-ID gesetzt. Jetzt müssen wir
diese Abfrage immer noch mit
der Methode execute ausführen. Und wenn Sie den Mauszeiger darüber bewegen, werden
Sie feststellen, dass diese
Methode eine Zeilendatenbankergebnisse
zurückgibt, aber wir müssen einen Raumtyp
zurückgeben. Also diese Execute
Query Execute Execute Methode funktioniert nicht mit
einer TypeScript-Umgebung. Deshalb gebe ich ein Gewicht
zurück und
suche nach dem aktualisierten Dokument. Da ist also das Raum-Repository und dann verwende die Methode
find one. Und ich
suche nach einem Zimmer mit oder wo die ID der Raum-ID
entspricht. Und um die Relationen
zurückzugeben, müssen
wir auch die
Relationseigenschaft hinzufügen und ein Array oder ein Array
der Relationen
angeben , die
wir abrufen möchten. In unserem Fall
haben wir nur eine Relation, nämlich das Array des Benutzers. Und das war's. Auf diese Weise können wir
eine Entität aktualisieren und sie
mit dem Query Builder zurückgeben.
33. CreateRoom Resolver 1/2: Bevor wir jetzt den Roomservice
nutzen, müssen
wir
die App-Datenquelle importieren eine Instanz erstellen
und hier eine Instanz erstellen
und das
Room-Repository übergeben. Lassen Sie uns also zuerst
die App-Datenquelle
von zwei Ebenen aus importieren die App-Datenquelle und dann die Datenquelle
auswählen. Jetzt müssen wir
eine Konstante exportieren und
sie Room Service nennen und eine neue Instanz
von Room Service erstellen. Und übergeben Sie die oder verwenden Sie die
App-Datenquelle und geben Sie dann den Punkt Git-Repository und die Raum-Entität
weiter. Und hier ändere das auf Export. In Ordnung, speichern wir
das und schließen es. Gehen Sie zurück oder öffnen Sie die Räume
der Resolver und importieren Sie als Nächstes den Roomservice-Service
aus der Roomservice-Datei. Und hier stellen wir die Nachricht ein
oder senden den Nachrichtenresolver. Lassen Sie uns die
Rückgabeerklärung löschen. Und wir werden das Gewicht
zurückgeben. Die Zimmer senden
diese Nachricht nach Rom und geben die Zimmernummer
zuerst von der Eingabe an mein D weiter. Und dann müssen wir die Nachricht
weiterleiten. Und die Nachricht ist ein Objekt
mit Eigenschaftsinhalt. Und wir werden den Inhalt
aus der Eingabe dieser Nachricht
abrufen . Außerdem müssen wir die Eigenschaft
from hinzufügen, die die ID des Absenders ist, in unserem Fall
die aktuelle Benutzer-ID. Und
das können wir aus dem Kontext abrufen,
diesem koreanischen Benutzer, dieser Benutzer-ID. Jetzt sind wir mit dem
Sandnachrichten-Resolver fertig. Fügen wir nun hier
ein Komma hinzu und
erstellen dann den Create Room Resolver. Also Async, erstelle Raum, dann für das Elternteil. Also hier Raum erstellen und
ich würde überziehen und dann Eingabe und den
Kontext
hinzufügen, den Kontext. Richtig? Hier
haben wir also create room, aber wir erhalten diese Fehler,
weil wir
den Ersteller der Mutation in
unserem Raum-GraphQL-Schema nicht definiert haben. Also lasst uns das ganz schnell machen. Hier. Lass uns eine weitere
Mutation erstellen und sie benennen. Raum schaffen. Und Eingabe des Typs. Raum erstellen, eingeben. Und definieren wir das hier. Eingabe, Raumeingabe erstellen. Also ich habe hier Autocomplete. Sehr nervig. Lass uns das reparieren. Und stattdessen
schaffen sie Platz im Buch. Wir akzeptieren
ein Nachrichtenfeld mit
einer Typzeichenfolge und einem Empfänger. Die Typen vom Typ int
bekommen die ID des Empfängers. Jetzt müssen wir hier den
Rückgabetyp zurückgeben. Also werde ich
die Zeile zurückgeben und dann speichern. Geh zurück zum Room Resolver. Und dafür müssen wir das Schema oder
die Typen
aus dem GraphQL-Schema generieren . Öffnen Sie also Ihr Terminal und
führen Sie npm aus, führen Sie generate aus. Im Moment glaube ich,
wir haben vergessen hinzuzufügen. Sehr wichtig ist
, dass unser Schema hier ist, das die Eingabe von Create
Room erforderlich machen soll. Andernfalls erhalten Sie
TypeScript-Fehler, wenn versuchen, die use
the create ROM-Eingabe zu verwenden. Lassen Sie uns diesen Befehl hier
erneut ausführen und ihn löschen oder
einfach das Terminal entfernen. Geh zurück. Als Erstes müssen wir den Benutzer
authentifizieren. Also werde ich das alles
kopieren und hier einfügen. Jetzt müssen wir überprüfen,
ob wir bereits
einen Raum haben , in dem sich der
Empfänger und der Absender befinden. Und dafür müssen wir innerhalb
des Zimmerservice
eine andere Methode entwickeln . Öffnen wir also den
Zimmerservice und
erstellen Sie hier eine weitere asynchrone
Funktion und nennen Sie sie, find, boom, mit der ID eines Benutzers. Ordnung, jetzt suchen wir oder suchen nach einem Benutzer nach einem
Raum mit der Empfänger-ID, der Typnummer und der
Absender-ID der Typnummer. Und hier werden wir
den Query Builder verwenden , um die Benutzerbeziehungen
abzurufen. Lassen Sie uns
hier eine Konstante erstellen und sie Query Builder nennen. Verwenden Sie dann das Raum-Repository , um eine neue Abfrage mit ihnen zu erstellen. Fügen wir
hier einen Alias hinzu,
der auf die Raumentität der
Raumtabelle in einer Datenbank verweist der auf die Raumentität der
Raumtabelle in einer Datenbank und erstellen wir eine Rooms-Konstante,
da wir
alle Räume abrufen werden, die
einen Benutzer mit der ID
Absender-ID enthalten . Also lass uns das machen. Warten Sie auf den Query Builder. dann in einer anderen Zeile Wählen
wir dann in einer anderen Zeile alles aus und verwenden
dann die Methode Inner Join um die gesamte Relation
innerhalb der
Benutzereigenschaft room dot zu verbinden . Also hier suchen wir
die Benutzer, dann fügen wir ein,
einen Alias hinzu, der auf
die Benutzerbeziehung verweist. Und ich werde hier
einfach den Buchstaben U wählen. Und dann fügen wir eine Who-Bedingung hinzu , bei der
die Bedingung erfüllt ist. Wir werden das Relations-Array
des Benutzers abbilden. Und zwar durch das Hinzufügen doppelter
Anführungszeichen wie dieses. Sie aureus, und fügen dann weitere doppelte
Anführungszeichen mit hier
weitere doppelte
Anführungszeichen mit
einem Punkt hinzu, um die ID auszuwählen. Und überprüfen Sie dann, ob die ID der
variablen Absender-ID
entspricht. Und hier können wir
diese variable Absender-ID definieren. Und dann werden
wir die Methode
Get Many verwenden , um viele Räume zu bekommen. Und dann verwenden wir JavaScript
, um einen booleschen Wert
zurückzugeben, return und fügen dann hier doppelte
Ausrufezeichen hinzu. Dann stehen Zimmer mit einem Fragezeichen
, weil wir Null bekommen können. Dann ist Summe die Summenmethode
, um zu überprüfen, ob einige Zimmer einen ganz bestimmten Zustand haben
, also gerundete Benutzer. Also werden wir überprüfen,
ob es eines der Zimmer ist. Und in der Eigenschaft dieser Benutzer finden
wir mindestens einen Benutzer , dessen AD dem Empfänger-AD
entspricht. Okay, jetzt haben
wir ein paar Methoden, aber es ist schwul. Und jetzt können wir verhindern mehrere Räume
für dieselben Benutzer
erstellt werden.
34. CreateRoom Resolver 2/2: Wenn wir nun einen Raum haben, der
zwei Benutzer mit der
Empfänger-ID und der Center-ID hat , werden
wir
keinen neuen Raum für sie erstellen. Also lasst uns
hier eine Konstante erstellen und ihr einen Namen geben. Der Raum hat Nutzer. Verwenden Sie dann den Zimmerservice , der Zimmer mit
Benutzer-ID oder Benutzer-ID sucht. Und dann müssen wir
die Empfänger-ID aus
der Eingabe, dieser Empfänger und
die Absender-ID aus den Kontexten,
diesen koreanischen Benutzer, diese Benutzer-ID übergeben Eingabe, dieser Empfänger und
die Absender-ID aus den Kontexten . In Ordnung, lassen Sie uns jetzt nachschauen. Wenn wir einen Raum mit
Benutzern haben, werfen wir YouGov KL zurück
und sagen, dass Empfänger bereits existiert oder
nur der Raum bereits existiert. Ja. Also hier gibt es schon Platz. Und das war's. Wenn wir nun keinen Raum
finden, in dem der
Empfänger und der Absender sind, senden oder erstellen
wir den Raum und
senden dann die Nachricht. Geben wir also 08 zurück, den Zimmerservice, der
die Zeile erstellt hat. Jetzt akzeptiert diese Methode das Array
eines Teilnehmers, das ein Benutzer-Array ist. Also müssen wir Benutzer
aus dem Benutzer-Repository abrufen. Und dafür
werden wir
eine weitere Methode innerhalb des
Benutzerdienstes erstellen ,
die mehrere
Benutzer anhand ihrer IDs zurückgibt. Erstellen wir also eine asynchrone Methode
und benennen sie nach ID. Weil wir eine Reihe von Ideen
übergeben und
There's find by ID in Array nennen. Und hier bei Ideas, Arguments of type,
array of numbers. Und kehre zurück. Warten Sie darauf, dass der
Benutzer-Repository-Punkt nach der ID
sucht,
die im Array der ID existiert. Und dafür verwenden wir
eine Methode vom Typ des RAM, die in method aufgerufen wird. Stellen Sie also sicher,
dass Sie das zuerst vom Typ ramp importieren, dann das Array der ID. Und die Methode findet alle Benutzer, deren IDs
innerhalb des Arrays existieren. Wir können diese
Methode also find by
IDs nennen , anstatt find
by ID in Array. Ordnung, jetzt
speichern wir den Benutzerdienst, schließen ihn und kehren hierher zurück. Und wir werden
eine Teilnehmerumfrage erstellen. Teilnehmer. Und werde
den Benutzerservice nutzen. Zuerst wird das aus
dem Off-Ordner und aus
der Benutzerservice-Datei importiert . Und dann warten Sie hier auf den
Benutzerdienst, der nach ID sucht. Und wir werden ein Array
mit zwei IDs aus den
Kontexten von currentUser übergeben . Ich werde die Benutzer-ID abrufen. Aus der Eingabe. Wir holen uns
die Empfänger-ID. Ja, dann hier, lassen Sie uns
die Teilnehmer
und die Nachricht weitergeben . Die Nachricht hat also
zwei Eigenschaften. Der erste ist der Inhalt. Kann das aus der
Eingabe dieser Nachricht
und der From-Eigenschaft abrufen, die den Empfänger
oder die Center-Array-ID
darstellt. Und das können wir von der
CurrentUser-Punkt-Benutzer-ID abrufen. Und das war's für den
Create Room Resolver.
35. getRooms erstellen: Jetzt
erstellen wir eine Abfrage, die alle Räume
aus der Datenbank
abruft. Also beginnen wir mit
dem Raum dieses GraphQL-Schemas und
definieren eine neue Abfrage. Und nenne diese Abfrage, hol dir Zimmer. Und es wird keine Eingaben
akzeptieren, aber es wird
ein Array von Objekten zurückgeben. Speichern wir dieses GraphQL-Schema
und generieren wir die Typen für die Resolver mit dem Befehl
NPM run generate. Ordnung, schließ das
Terminal im Raum, diese GraphQL-Datei und dann geh
zurück zu den Raumresolvern. Und hier unter der Mutation werde ich eine Abfrage definieren. Definieren Sie dann den Resolver von Get
Rome. Und wir werden
ein übergeordnetes Element und eine leere
Eingabe und den Kontext bekommen . Und hier müssen wir den Benutzer
authentifizieren. Also lass uns das kopieren
und hier einfügen. Jetzt müssen wir innerhalb
des Zimmerservice
eine neue Methode entwickeln , die alle Zimmer für uns
abholt. also oben hier Erstellen Sie also oben hier eine neue asynchrone Methode
und benennen Sie sie, rufen Sie alle Gruppen ab. Und wir werden alle
Räume für einen bestimmten Benutzer bekommen. Also hier akzeptieren wir eine
Benutzer-ID vom Typ Nummer. Und wir werden
den Query
Builder verwenden , um
die Benutzerbeziehungen abzurufen und dann
alle Räume zurückzugeben , die einen
Benutzer mit dieser Benutzer-ID haben. Definieren wir also zunächst den Query Builder aus
dem Room-Repository. Erstellen Sie Query Builder und
wählen Sie einen Alias-Raum aus. Und dann
verwenden wir hier den Abfrage-Editor. Ich werde also
08 Query Builder zurückgeben. Und dann werden wir
die Benutzertische in dem Raum zusammenfügen die Benutzertische in dem ,
der dem
Benutzer am Zimmertisch gehört. Also hier ist Inner Join,
verbinde die Relationstabellen
und wähle abgerundete Benutzer aus. Und wir beziehen uns auf das Benutzer-Array
mit dem Buchstaben U und dann verwenden wir
hier das Wort Bedingung. Und wir wählen
alle Räume aus, die
einen Benutzer mit einer ID haben, die der variablen ID
entspricht. Wir können hier die
variable ID definieren, SAT, diese Objekt-ID
entspricht der Benutzer-ID. Und dann werden wir
viele, viele Zimmer bekommen. Also werden wir das
benutzen, uns viele besorgen. Gerade jetzt.
Speichern wir das und kehren wir zu den Raumresolvern
in der Get Room-Abfrage zurück. Wir geben ein Gewicht zurück. Roomservice, ruft alle Routen ab und übergibt
die Benutzer-ID aus den Kontexten, CurrentUser und dann Benutzer-ID.
36. Graphql enpoint testen: Jetzt ist es an der Zeit, unsere APIs zu testen. Stellen Sie also sicher, dass die
Postgres-Datenbank läuft. Und das können Sie
mit diesem Befehl tun. Stellen Sie sicher, dass Sie
die richtigen Anschlüsse freigeben. Und dann komm her und führe npm aus. Start ausführen. In Ordnung, jetzt navigieren wir
zu einer Polo-Sandbox. Stellen Sie sicher, dass Sie sich
anmelden und das
JWT-Token in die
Verbindungseinstellungen
und in den
Autorisierungsheader kopieren JWT-Token in die
Verbindungseinstellungen . Jetzt, stille Mutation, testen
wir die,
die Mutation zum Senden von Nachrichten. Aber zuerst müssen wir
einen anderen Benutzer erstellen , an
den wir eine Nachricht senden können. Ja, lass uns hier sein. Sie die
Anmeldemutation mit dem Benutzer erneut an die E-Mail und den
Vornamen und führen Sie die Anmeldung aus. Dieses Mal werden
wir dieses JWT-Token nicht in
den Autorisierungsheader
kopieren da wir
uns als erster Benutzer
oder als einer dieser Benutzer authentifizieren müssen. Ja. Also hier haben wir den Benutzer mit id2
und wir werden ihm eine
Nachricht
mit dem, mit seinem AD schicken. Das ist also klar. Dadurch wird die
Anmeldemutation entfernt und die Eingabe entfernt. Klicken Sie auf Nachricht senden. Und die Mutation „Nachricht senden“. Wir werden die ID-Benutzer
und die Nachrichten des Raums abrufen . Also sagte ich die Benutzer. Nehmen wir als
erstes den Vornamen und die ID. Und dann für die Nachrichten, die Formularfeld oder
Absenderfeld
passen und dann zum Inhalt. Okay, jetzt zu den Eingaben, wir müssen die
Nachricht und die Raum-ID hinzufügen. Aber wir haben
noch keine Zimmer in unserer Datenbank. Wir
müssen also einen Raum
erstellen, bevor wir die Nachricht
senden. Fügen wir also das Create
Through-Mutation hinzu und fügen wir hinzu. Lassen Sie mich das alles zuerst klären. Und dann haben wir
create room oder the hinzugefügt, alle Felder hier. Und für die Benutzer erhalten
Sie die ID
und den Vornamen, die Nachrichten, von
denen wir ihn erhalten werden. All das ist uns egal, wenn
wir nur eine Nachricht senden. Auch hier werden wir
eine Nachricht an einen Benutzer senden. Ja. Lassen Sie mich überprüfen, welche
Felder wir haben, die Nachrichten haben Inhalt. Gehen wir jetzt zurück.
Und die Eingänge. Lassen Sie mich die gesamte
Nachricht löschen und den Empfänger hinzufügen. Der Empfänger wird
ein Benutzer mit id2 sein und die Nachricht ist genauso einfacher
Text wie Textnachricht. Lassen Sie uns nun den
Raum senden oder erstellen und die Nachricht senden. In Ordnung, wir haben hier das
Raumobjekt mit der ID eins. Und wir haben die Vielzahl von Benutzern. Ja, und wir haben die
ID des Benutzers eins. Ja, FirstName ist einer und der zweite Benutzer
in diesem Raum. Diese beiden Benutzer
können sich jetzt gegenseitig Nachrichten senden. Wir haben hier das
Nachrichten-Array mit nur einer Nachricht. Und diese Nachricht wurde vom Benutzer mit ID1
gesendet. Also der Benutzer eins. Wenn wir nun versuchen, einen anderen Raum mit
derselben Empfänger-ID zu erstellen, sollten
wir eine Fehlermeldung erhalten,
die besagt, dass dieser Raum bereits existiert. Also schauen wir mal, ob es funktioniert. Ordnung, also hier haben wir
den Nachrichtenraum, der bereits existiert und wir können loslegen. Die nächste Mutation, die
wir testen werden,
ist also die Sandnachricht. Lassen Sie mich also all
diese Eingaben löschen und die Mutation „Nachricht
senden“ hinzufügen. Wir werden uns
die Vorstellung von dem Raum, der ID des Benutzers und dem Vornamen des Benutzers machen. Und dann werden wir
auch die Nachrichten hier bekommen. Ich werde das
Absenderfeld abrufen, das Inhaltsfeld. Und dann müssen
wir für die Eingaben eine Nachrichteneingabe hinzufügen,
Iran, mein D-Eingang wird
eine Nachricht
an den Raum senden , ID eins. Und lassen Sie uns eine Nachricht hinzufügen, weitere Testnachricht, und
dann eine Nachricht senden. Und los geht's. Wir
haben den gleichen Raum, ein Raumdokument mit
den gleichen Benutzern. Und hier haben wir
dem Nachrichten-Array eine
weitere Nachricht hinzugefügt . Und user2 kann auch
Nachrichten an diesen Raum senden, aber wir müssen uns als Benutzer
anmelden, um das JWT-Token zum Autorisierungsheader hinzuzufügen
und dann die Nachricht zu senden. Lass uns das sehr schnell machen. Also eine plötzliche Mutation. Lassen Sie mich das alles klären. Und bei der Anmeldemutation erhalte ich nur das JWT-Token. Also hier, entferne dieses JWT-Token. Für die Eingaben benötigen wir
die E-Mail und das Passwort. Das alles. Die E-Mail von
fuser two lautet also user to add email.com und das
Passwort ist password. Jetzt melden wir uns an. Und denken Sie daran, dass wir eine
Nachricht an Raum ID1 schicken werden. Nehmen wir also das JWT-Token dem
Autorisierungsheader
hinzugefügt wurde. Und sicher. Jetzt sind wir als Benutzer angemeldet Gehen
wir zurück zur Mutation,
entfernen das Zeichen jeder Mutation
und melden uns die Eingaben an. Und hier sind die Mutation zum
Senden von Nachrichten. Ich werde mir die
Idee des Raums, die Idee der Benutzer, vielleicht auch den Vornamen holen. Und ich werde
alle Nachrichten bekommen. In Ordnung, fügen wir die Eingaben hinzu. Die Nachrichteneingabe,
die Raum-ID-Eingabe. Also sagte ich, dass wir
eine Nachricht an meinen D1 schicken werden. Und die Nachricht ist eine Nachricht von Benutzer zu Benutzer
. Senden Sie Nachrichten. Und los geht's. Wir haben dieselbe Raum-ID, Raumdokument
zur Raum-ID, dieselben Benutzer und eine neue Nachricht
im Nachrichten-Array. So können wir
mit dem Raumkonzept Nachrichten senden.
37. Validierung mit Class Validator implementieren: Jetzt werden wir unserem Projekt die
Validierung hinzufügen. Und dafür werden wir
die Klassenvalidator-Pakete verwenden . Also Sage oder ein Terminal-NPM
- und Style-Klassenvalidator. Und der Grund, warum
wir den
Cluster der Daten verwenden werden, sind die Dekoratoren der klassifizierten
Daten. Und wir werden die
Zeichen Class Validator
in den Entitäten verwenden , um zu
überprüfen, ob wir z.B.
eine gültige E-Mail haben oder um bestimmte Bedingungen
auf das Passwort
anzuwenden. Um also zunächst eine
E-Mail der Benutzerentität zu validieren, importieren
wir sie
aus dem Klassenvalidator. Der
Charakter wird per E-Mail importiert. Das ist also ein Dekorateur
, den wir benutzen können. Backen Sie hier andere Windeldekorateure
. Wenden Sie den Dekorateur auf
diese Immobilie an, indem Sie eine E-Mail senden. Und Sie können in
der Definition hier sehen, dass dieser Decorator überprüft, ob es sich bei
der Zeichenfolge um eine E-Mail handelt. Wenn der angegebene Körper keine Zeichenfolge ist, wird false zurückgegeben da jeder Mann immer eine Zeichenfolge
sein sollte. Nun zum Passwort werden
wir die
Länge des Passworts überprüfen. Ja. Also hier brauchen wir einen anderen, den Charakter, der Min Nan
ist. Wenden Sie es dann auf die
Passworteigenschaft an. Also hier ausführlich. Und das Minimum
für das Passwort
ist dann sechs
und die Datei speichern. Natürlich können Sie mehr erkunden. Die Charaktere
im Cluster-Mediator schreiben
einfach so. Und Sie können viele
der Zeichen finden, viele
Dinge wie Großbuchstaben
zu überprüfen, z. B. um zu überprüfen, ob eine
Eigenschaft eine URL ist oder ob es sich um ein Array handelt. Und viele Dinge wie
auch wenn es leer ist oder nicht, oder es ist groß oder klein geschrieben.
Und viele Dinge, ja. Also überprüfe das alles und spiele mit
dem Klassenvalidator herum. Jetzt lernen wir, wie
man mit der Validierung umgeht.
38. Validierungsfehler: Jetzt werden alle
Zeichen zur Validierung
ausgeführt, wenn wir eine neue Entität
erstellen. Und bevor wir diese
Entität in der Datenbank speichern, verwenden
wir
eine andere Methode von Class Validator, um
alle Validierungsfehler abzufangen. Schauen wir uns also
den Benutzerservice an. Und hier, wo wir
eine neue Benutzerentität erstellt haben, importieren
wir zuerst die Methode, validieren oder ablehnen aus
dem Klassenvalidator. Und wir werden diese Methode verwenden , bevor wir die Benutzerentität
speichern. Hier. Warte, bestätige oder lehne ab. Dann
validieren wir die Benutzerentität. Und dann
verwenden wir die Catch-Methode,
um die Vibrationen
oder die Validierungsfehler abzufangen. Hier definieren wir also
einen Callback, der die Fehler
des Typvalidierungs-,
Validierungs- und Fehlerarrays abfängt . Und wir können diesen Typ
aus dem Klassenvalidator importieren. Also hier, Portvalidierungsfehler vom Klassenvalidator und
fahren Sie mit dem Callback fort. Also werden wir einen neuen GraphQL-Fehler ausgeben, wenn
wir irgendwelche Fehler hatten. Ja, so wichtig, der GraphQL. Graphql und ich werde
einen
Nachrichtenvalidierungsfehler mit Erweiterung zurücksenden . Erweiterungen. Und wir werden alle Pfeile
zurückschicken. Ja, mit dem Code
, den der Benutzer eingegeben hat. Jetzt haben wir hier zwei Probleme. Das erste ist
, dass das Passwort belästigt wird. Wenn der Benutzer also ein
dreistelliges Passwort sendet, erhalten
wir ein, wir validieren nur
das Gefahrenpasswort,
bei dem es sich um ein Passwort mit langer Zeichenfolge handelt. Ja. Und das zweite Problem ist , dass wir, obwohl
wir hier einen Fehler ausgeben, immer noch einen Running durchführen und diese Zeile hier
ausführen, diese Zeile hier
ausführen, wir werden den Benutzer trotzdem speichern. Um all
das zu verhindern, werden
wir
die Then-Methode verwenden. Und hier in einem Rückruf. Wir nehmen diese Neun. Hier hinzugefügt. Entferne das Passwort
aus der Create-Methode
und gib einfach die Aura an. Lassen Sie die
Anmeldeeingabe einfach so. Und wir werden
das Passwort hier ändern. Stellen Sie sicher, dass diese Methode
asynchron ist , da
wir ein Gewicht verwenden werden. Wenn wir nun das Passwort, das
Passwort, generieren, nehmen
wir die Benutzerentität und ändern das Passwort so, dass es dem Hash-Passwort
entspricht. In Ordnung, jetzt haben wir das erste Problem
behoben. Um das Problem zu lösen, wir den Benutzer zurück. Wir speichern den
Benutzer und geben das,
speichern Sie ein Dokument von hier aus zurück . Und dann werden wir hier ein Ergebnis
bekommen. Dieses Ergebnis ist dasselbe
, das der Benutzer hier sehen kann. Das Ergebnis ist vom Typ
user, da
wir hier den Benutzer von dort zurückgegeben haben. Also verwenden wir hier einfach die
Rückgabeerklärung. Und das war's. Oder wir haben hier tatsächlich
einen Fehler gemacht. Wir sollten die
Katzenmethode nicht vor der damaligen Methode anwenden. Ja, also sollte die
Catch-Methode die letzte, die letzte Methode sein. Also hier, fange alle Fehler auf. Wenn wir hier also einen Fehler haben, senden
wir früher ein Diagramm
zurück. Aber wenn wir keine
Fehler gefunden
haben, werden wir
das ausführen, geh zurück. Ordnung, jetzt können wir diese Datei
speichern und dann den Server
vom Terminal aus ausführen. Also hier, das habe ich schon
gemacht. Und Sie können sehen, dass Node
Man den ganzen Server
neu startet,
weil wir die Datei geändert haben. Und jetzt testen wir unsere API auf dem
Apollo-Server, ich meine die erschwingliche Sandbox. Also hier haben wir unsere
Anmeldemutation. Also werde ich eine gültige
E-Mail und ein gültiges Passwort senden. Also werde ich ein
dreistelliges Passwort senden und die Anmeldemutation
ausführen. Und wir sollten eine Bestätigung bekommen. Los geht's. Also müssen wir hier
zwei Arrays haben und sagen, dass das
Fehler-Array widerlegen muss,
bedeutet, dass wir zwei Fehler
bekommen haben. Der erste Fehler
betrifft die E-Mail. Also hier Eigentum, E-Mail. Und Sie können sehen, dass
die Verträge, die wir haben, Eigentum
der E-Mail sind. Und bei der Nachricht muss
E-Mail eine E-Mail sein. Und für das Eigenschaftspasswort können
Sie sehen, dass
das Nachrichtenkennwort jünger als oder gleich
sechs Zeichen
sein muss . Jetzt wissen wir also, dass unsere
Validierung funktioniert. Mit dem Klassenvalidator können Sie weitere Validierungen hinzufügen. Sie können jetzt
die Raum-Entität validieren und mit
den Clustering-Daten herumspielen. Bevor ich dieses Video beende, möchte
ich darauf hinweisen, dass, wenn Sie
die Postgres-Datenbank schließen ,
indem Sie Strg C drücken,
wie hier, n haben und es dann mit
dem Befehl docker run erneut schreiben. Sie müssen
den GraphQL-Server mit dem
Control C schließen und erneut ausführen. Ja, führen Sie es erneut aus, wenn
die Postgres-Datenbank jetzt bereit ist, Verbindungen zu akzeptieren. Andernfalls
erhalten Sie viele Fehler und können
nicht mit der Datenbank arbeiten.
39. Warum wir ScoketIo verwenden sollten: Jetzt können wir
Nachrichten zwischen Benutzern senden, aber damit ein Benutzer die neueste Nachricht
sehen kann, muss
er
den Browser neu laden oder z. B. verwenden wir
hier Sandbox. Wir müssen alle
Räume abrufen, um die neuesten Nachrichten zu sehen ,
die vom Teilnehmer dieser Regel gesendet wurden. Und Sie wissen, dass die Benutzer das nicht
zu schätzen wissen werden , da alle Messaging-Apps jetzt
über eine Art
Echtzeit-Datenübertragungsmechanismus verfügen , sodass Benutzer
neue Nachrichten in
Echtzeit ohne Licht abrufen und lesen können , die Seite
aktualisieren oder
eine App schließen und erneut öffnen um die Räume abzurufen und Ihnen die neuesten Nachrichten zu senden. Und das ist die Funktion , die wir
in unserer Anwendung implementieren müssen. Wir werden also Socket IO verwenden, eine sehr beliebte
Bibliothek, die die
Echtzeitkommunikation zwischen
Webclients und Servern ermöglicht . Sie können zu
Socket Dot io navigieren und
die Dokumentation lesen und sich einige Beispiele
ansehen. Ja, aber natürlich werden
wir in diesem Projekt mit
Socket IO arbeiten , und wir werden
im nächsten Video beginnen.
40. Räume mit socketIo verbinden: Beginnen wir nun mit der Installation von
Socket IO von MPM. Öffnen Sie also Ihr Terminal und
führen Sie npm install socket IO aus. Ordnung, lassen Sie uns jetzt das Modul,
die ts-Datei,
öffnen und dort
den Socket-IO-Server implementieren. Lassen Sie mich hier das Terminal schließen. Open Modular Tears Fire. Und als erstes
müssen wir
die Serverklasse
aus dem Socket dieser IL importieren . Jetzt implementieren wir
den Socket-IO-Server in der Autostart-Methode und
implementieren ihn mit
dem HTTP-Server. Also hier erstellen wir
die
A0-Konstante und erstellen eine
neue Serverinstanz, übergeben den HTTP-Server. Und jetzt müssen wir anfangen
, nach Verbindungen zu suchen. Und das können wir
mit der on-Methode machen
und hier auf das
Verbindungsereignis warten, connection. Dann
fügen wir hinzu und kehren hierher zurück. Das wird eine Steckdose bekommen. Und wir werden etwas
mit solchen Gets machen. Um also den Socket in
all unseren Resolvern
verwenden zu können , fügen
wir ihn
in die Anfrage ein und wir können über die Anzeigenkonstante auf die
Anfrage zugreifen. Fordern Sie dann
eine benutzerdefinierte Eigenschaft an und erstellen Sie sie,
nennen Sie sie Socket IO und setzen Sie sie auf den Socket, den wir vom Client
erhalten haben. Jetzt müssen wir die
Socket-IO-Eigenschaft zur
Anforderungsschnittstelle hinzufügen , und das werden wir
in der Datei main.js tun. Also lass es uns öffnen. Und darin deklarieren
wir eine
globale Variable oder einen Namespace. Und wir werden
den Namespace Express auswählen. Und darin
wählen wir die Schnittstellenanfrage aus. Und hier können wir das
Socket-IO hinzufügen und es als nicht erforderlich festlegen. Und dann
wird der Socket-IO vom Typ Socket sein. Wir können diesen Typ aus
dem Socket-IO-Paket importieren und dann diese Datei speichern und dann zum
Modul, der ts-Datei, zurückkehren. Und Sie können sehen
, dass der Fehler darin besteht, der Fehler verschwunden ist. Jetzt. Da wir
das Raumkonzept
in unserer Anwendung verwenden , können
wir
dasselbe mit Socket IO tun. Also werden wir
den Client-Socket verwenden um alle Räume zu verbinden
, die der Benutzer hat. Und wenn wir dann
ein neues Event in einen
dieser Räume senden , und ich habe natürlich keine Steckdose, die den Raum
nicht angeschlossen hat, wird das Ereignis nicht empfangen. Also werden wir das alles innerhalb des
Kontextes machen. Und hier
müssen wir überprüfen, ob die, ob wir eine Nutzlast haben. Ja, wenn ja, holen wir
uns alle Zimmer
aus der Datenbank. Um das tun zu können, müssen
wir
hier eine Konstante erstellen und die aktualisierte
Quellinstanz abrufen. Also hier, erstellen Sie unsere Datenquelle. Und wir werden
es verwenden, um alle Räume einzurichten. Also hier bei Data Source, Punkt Manager, ich werde den Manager und dann
das
Git-Repository verwenden . Und wir werden
das Zimmerdepot besorgen. Importiere also die
Raum-Entität und verwende sie hier. Dafür ist von hier aus Platz. Und portiere die Raum-Entität. Aus der
Raummappe im Raum. Wählen Sie die NSAID-Entitäten
wie die Raumentität aus. Nun verwenden wir hier den Raum, um das Raum-Repository
auszuwählen. Und dann verwenden wir, wir werden einen Query Builder erstellen, einen Alias für den Raum. Und dann wählen wir alle Räume aus, die die Benutzer-ID
enthalten. Dafür müssen wir also
Inner Join verwenden, um alle Benutzertabellen
der Rome-Dot-Benutzer zusammenzuführen und einen
Alias für das Benutzer-Array hinzuzufügen. Und dann füge hier eine
Where-Bedingung hinzu
und durchsuche
das gesamte Benutzer-Array und wähle
nur alle aus deren Benutzer-ID
der ID-Variablen entspricht. Und wir werden
die ID des Benutzers aus
der Payload abrufen , diese Benutzer-ID. Okay, jetzt fügen wir hier
eine weitere Methode hinzu
, um viele Räume zu bekommen. Und hier erstellen wir eine
Konstante und nennen sie Rooms. Und warte auf das
Ergebnis. In Ordnung. Hier erhalten wir nun
eine Reihe von Formularobjekten. Und dann verwenden wir
die Socket-IO aus der
Anfrage, um ihnen beizutreten. Also hier, Quest Dot
Socket IO, die beitreten. Und diese Methode
ermöglicht es uns , der Steckdose Räume hinzuzufügen. Und Sie können hier sehen, dass wir entweder ein einzelnes Zimmer
oder eine Reihe von Formularen
hinzufügen können . Jetzt brauchen wir eine eindeutige
Referenz für, das stimmt. Für uns. Wir haben die Raum-ID als
Referenz, aber es ist Zimmer. Es ist, die Raumreferenz
sollte eine Zeichenfolge sein. Also hier haben wir eine Zeichenfolge und hier haben wir eine
Reihe von Zeichenketten. Aber wie Sie wissen, sind
die Raum-IDs Zahlen. Also werden wir sie
in Zeichenketten umwandeln. Und wir werden
ein Array von Zeichenketten-IDs erstellen. Erstellen Sie hier eine Raum-ID, und führen Sie dann das
Raum-Array und die Karte durch alle Räume und geben Sie eine Zeichenfolge mit
der Literalzeichenfolge zurück
und geben Sie die Raumpunkt-ID zurück. Jetzt haben wir ein Array von Zeichenketten. Also lass es uns hier weitergeben. Zimmerausweise. In Ordnung,
jetzt sind wir fertig. Aber hier haben wir einen Fehler besagt, dass die
Payload keine Benutzer-ID-Eigenschaft hat und
dass die Payload vom Typ String oder einer JWT-Palette ist . Wir können das beheben, indem wir
überprüfen, ob
der Payload-Typ nicht der Zeichenfolge
entspricht. Und wir müssen überprüfen,
ob wir eine Nutzlast haben. Ja. Dann können wir
die Benutzer-ID-Eigenschaft verwenden. So können
wir nun Räume verbinden. Im nächsten Video
werden wir lernen, wie man Ereignisse
an eine bestimmte Gruppe sendet.
41. Nachrichten in einen bestimmten Raum senden: Um nun Ereignisse auszusenden, müssen
wir die IO-Konstante verwenden, die die
Socket-IO-Instanz darstellt, und wir müssen sie
an den Rückgabewert
der Context-Methoden übergeben , damit wir sie in unseren Resolvern
verwenden können . also hier in diesem Objekt Fügen Sie also hier in diesem Objekt A0 hinzu und speichern Sie das
Modell in der ts-Datei. Dann in der Room
Dots-Servicedatei. Hier verwenden wir die IO-Instanz innerhalb
der Methode „
Ad Message to Room“. Lassen Sie uns hier also
als Argument
vom Typ Server hinzufügen und stellen Sie sicher, dass Sie hier das Fragezeichen
hinzufügen. Weil
es manchmal bekannt sein kann. Nun zum Server hier, kann dies aus dem
Socket-IO-Paket importieren. Und nachdem wir
den Raum aktualisiert und dem Nachrichtenfeld eine neue
Nachricht hinzugefügt
haben, können wir hier nachsehen. Wenn wir kein IO haben,
werden
wir in diesem Fall ein neues
Ereignis mit der Image-Methode aussenden. Jetzt
akzeptiert diese Methode zwei Argumente. Das erste Argument ist
der Name des Ereignisses und das zweite Argument
ist ein beliebiger Datentyp. Es kann ein Array oder Objekt oder eine Zeichenfolge oder sogar ein JSON sein. Auch hier ist Jason
nur die richtige Saite. Also hier können wir
die Ereignisnachricht benennen. Und für die Daten hier senden
wir ein Objekt, senden
wir ein Objekt die Nachricht
und die Raum-ID
enthält. In diesem Fall senden
wir dieses Ereignis nun für alle verbundenen Benutzer aus. Aber das wollen wir nicht. Wir möchten diese
Nachricht an eine bestimmte Regel senden. Also werden wir hier
eine andere Methode anwenden ,
bevor sie emittieren. Diese Methode ist die Methode und übergibt die
Raum-ID als Zeichenfolge. Verwenden wir also die literale
Zeichenfolge und fügen die Raum-ID hinzu. Jetzt werden wir diese
Nachricht, dieses Ereignis, nur
an zwei Benutzer senden , die an diesem Raum
teilgenommen haben. Speichern wir das jetzt. Und in dem Raum, löst, und im Resolver zum
Senden von Nachrichten. Wir übergeben das IO hier an der AL
vorbei aus dem
Kontext, dass I0 ist. Das war's. Jetzt speichern wir das und
das ist der effektive Jahreszins.
42. socket testen: Mit der Apollo-Sandbox können wir keine Ereignisse abhören. Deshalb habe ich
eine sehr einfache
Anwendung erstellt , mit der wir Nachrichten
senden und empfangen können ,
indem wir auf Ereignisse achten. Und all diese Logik befindet sich
in der Datei index.js. Sie können hier sehen, dass ich mich
mit dem Server verbinde. Und hier habe ich ein paar Fragen und Mutationen, um die Nachricht zu senden. Und hier höre ich auf das Connect-Event und
auf das Message-Event. Und wie Sie hier sehen können, analysiere ich die Daten
in das HTML-Dokument. Um diesen Server zu betreiben,
benötigen Sie also eine Erweiterung
namens Live Server. Also hier musst du nach der
Live-Server-Erweiterung
suchen und sie in deinen VSCode installieren. Dann wirst du feststellen, dass du hier
einen Button bekommen würdest .
Lass mich die Verbindung trennen. Ja, du findest eine
Schaltfläche mit der Aufschrift Go Live, klicke darauf und
dann hast du einen Live-Server. Lassen Sie mich also den Server erneut ausführen und mit dem Testen
der Anwendung beginnen. Das ist es, das ist
die Vereinfachung. Ich habe nur einen Ort, an dem ich das
JWT-Token ablegen und mich anmelden muss . Dann werden wir hier die Nachrichten
senden. Ich habe hier zwei Browser, also zwei Instanzen
derselben Anwendung. Jetzt müssen wir den
Kurs innerhalb des
Socket-IO-Servers aktivieren , um über diese URL eine Verbindung herstellen
zu können. Also kopiere das. Und dann fügen
wir hier im
Modul, der TS-Datei und innerhalb des Stockdale-Servers und innerhalb des Stockdale-Servers ein neues Objekt hinzu und
legen die Kursoption fest. Stellen Sie den Ursprung auf
diese URL ein und speichern Sie sie. Dann lass uns hierher zurückkehren
und sicherstellen, dass du deinen Server neu gestartet hast. Und wir werden das
JWT-Token aus der Sandbox holen. Stellen Sie hier also sicher
, dass
Sie sich anmelden und dann das JWT-Token kopieren und dann in eine
dieser Anwendungen einfügen. Klicken Sie auf Anmelden. Und dann habe ich mich als
ein anderer Benutzer angemeldet und das Token
gespeichert. Also werde ich es hier einfügen. Stellen Sie sicher, dass Sie
dasselbe tun. Klicken Sie auf Anmelden. Und jetzt testen wir den Server, gehen in den Sand
und es hat nicht funktioniert. Und das liegt daran, dass
wir
hier, in Ordnung, den Schlamm
vom Ende der URL entfernen müssen. Gehen wir also zurück zum
Modul, die Tränen weit. Entfernen Sie den Schlamm von dort und stellen Sie sicher, dass der
Server neu gestartet wurde. Lass uns warten und dann erneut testen. Ordnung, Sie können
sehen, dass wir jetzt
verbunden sind , weil wir hier
die Verbindungsnachricht haben. Wenn ich jetzt auf Sand klicke, sollten
wir hier hoch kommen. Und hier müssen wir vielleicht die Anwendung
neu laden. Lassen Sie uns also das JWT-Token kopieren, neu laden und dann erneut
auf Anmelden klicken. Und vielleicht das
Gleiche hier, weil
wir zu den Räumen gehen müssen. Und vorher haben wir das glaube ich
nicht auf dem Server gemacht. Also lass uns anmelden und High schicken. Ordnung, wir haben
dieselbe Nachricht in den beiden Instanzen hier erhalten, die hier wie Hallo
senden. Und los geht's, unsere
Anwendung funktioniert. Nun, wie ich am
Anfang dieses Videos sagte, finden
Sie den Quellcode Anhang, damit Sie
ihn herunterladen und selbst testen können.
43. Datenbankmigration mit Typeorm: Jetzt sind wir mit der
Entwicklung unserer API fertig, aber wir müssen uns noch um eine Sache
kümmern, nämlich wenn wir unsere Entitäten aktualisieren
möchten. In diesem Fall müssen wir auch unsere Datenbank
aktualisieren. Wenn Sie also z.B. hier
FirstName in Only Name ändern möchten, müssen wir
natürlich unsere Dateien
aktualisieren, aber vor allem
müssen wir unsere Datenbanktabellen aktualisieren. Wenn wir es nun verkaufen, unser Projekt einschließlich der
Datenbank in die Produktion zu bringen. Wir haben also
keine importierten Daten. Wir können die
Datenbank herunterfahren und
erneut ausführen , um
alle Tabellen zu entfernen und neue zu
erstellen. Aber wenn wir unser
Projekt bereits in die Produktion gebracht haben, haben
wir aktive Benutzer, z. B. diesem Fall, sollten wir nicht dem ersten
Ansatz
folgen, da wir nicht
alle unsere Benutzerdaten verlieren wollen. Und es wird auch eine
große Katastrophe für unsere App sein. Was wir also hier tun sollten, nun, die App-Datenquelle, wir haben diese Eigenschaft
synchronisiert und auf true gesetzt,
bedeutet, dass wir
unsere
Datenbanktabellen jedes Mal aktualisieren , wenn Sie
eine Änderung an unseren Entitäten vornehmen. Diese Substanz
wird nur
Namen und Typen einiger Spalten ändern , aber sie wird keine Daten
beibehalten. Diese Option ist also
genauso gefährlich wie das
Herunterfahren der Datenbank
und das erneute Ausführen. es kurz zu machen:
Die einzige Möglichkeit, Datenverlust zu
verhindern ist die Verwendung einer
sogenannten Datenbankmigration. Es gibt viele
Möglichkeiten, das zu tun. Mit dem Typ ramp können wir jedoch automatisch Dateien
generieren, die geheime Abfragen
enthalten,
die für die Integration verantwortlich sind. In gewissem Sinne ist die
Synchronisierungsoption also falsch und sicher. Und Sie müssen mithilfe
des Docker-Befehls
sicherstellen, dass wir
eine laufende Datenbank haben . Und wir müssen unseren Server betreiben damit wir die
Benutzertabellen und die Bone-Typen erstellen können. Ordnung, gehen wir jetzt zur Benutzerentität und ändern
den Vornamen in den Namen und
generieren dann eine Migration. Also hier, benennen, speichern und lassen Sie uns
das GraphQL-Schema
hier von FirstName auf Name aktualisieren . Und das Gleiche, geben
Sie den
Benutzertyp an, Vorname, Tunika, Speichern. Und hier werden wir das Schema
generieren. Es ist gescheitert
, weil wir das
selbst generieren müssen . Also hier npm run generate und dann werden wir den Server erneut
ausführen. In Ordnung, npm startet. Jetzt werden wir die Datenbank nicht aktualisieren,
da wir
die
Synchronisierungsoption auf false gesetzt haben . Also
warten wir hier auf den Server und generieren dann
die Migrationsdateien. In Ordnung, jetzt
öffnen wir ein anderes Terminal. Und um die
Negation von Phi zu erzeugen, müssen wir dieses Programm
mit diesem
Befehl global in unserem Projekt
installieren . Ja. Und manchmal müssen Sie
das Schlüsselwort hinzufügen , um Administratorrechte zu
erhalten. Und wenn Sie sich auf einem
Windows-Computer befinden und eine Administratorkonsole
öffnen müssen . Ich werde
das also nicht tun, weil ich in meinem System bereits global
den Starttyp Rampe aktiviert habe. Also gehe ich zum nächsten Schritt über, bei dem NP x verwendet wird, ein Paket, das standardmäßig
ohne GS und NPM
geliefert wird. Und ich werde das
Band mit dem ts-Knoten und
dem
CommonJS-Modul für JavaScript herumlaufen lassen . Und wir werden die Regression
ausführen, Carlin generieren und den Speicherort
unserer Iterationsdateien angeben. Ich möchte den Quellordner der Websites und in einem Migrationsordner haben. Und dann erhalten wir Dateien mit Zeitstempel und Migrationsschlüsselwort. Wir werden also
Dateien mit Zeitstempel erhalten, macht Regressionspunkt Ja. Okay, jetzt müssen wir
den Standort der
App-Datenquelle angeben . Also hier, Quelle der niederländischen
Datenquelle, ja, das ist alles. Lassen Sie uns diesen Befehl ausführen.
Und los geht's. Wir haben
die
Einwanderungskämpfe für eine Datei erfolgreich generiert . In diesem Fall. Diese Datei ist eine TypeScript-Datei mit einer Klasse. Und hier können Sie den Namen, die
Dauer und einen Zeitstempel sehen. Dann haben wir hier zwei
Methoden rauf und runter. Die Methode add wird also jedes Mal
ausgeführt ,
wenn wir das ausführen,
jedes Mal, wenn wir
diese Migration ausführen. Und wir werden
diese Sequel-Abfrage ausführen , bei der der Vorname in den Namen
geändert wird. Jetzt kann die Down-Methode verwendet werden , um die hier dargestellten
Einwanderungen rückgängig zu machen. Sie können hier die Abfrage sehen , die den
Namen in FirstName ändert. Wenn wir also unsere Meinung ändern und Einwanderung rückgängig machen
wollen, können
wir die Stadtmethode anwenden. Und natürlich wird all
dies automatisch
mit dem Typ RAM CLI
ausgeführt. Um diese Regression auszuführen, gibt es zwei Möglichkeiten, dies zu tun. Erstens können wir hier den gleichen
Befehl verwenden, der sich jedoch geändert hat. Nur ein paar Dinge, wie die Datenquelle
zu behalten und diese Neun hierher zu
verschieben und die Rate auf Run zu
ändern. Das war's. Und wir können die
Einwanderung durchführen und wir werden eine aktualisierte Datenbank bekommen. können das tun, oder Sie
können die Migration
innerhalb oder vom Band
automatisch ausführen , indem Sie
die Datenquelle hier verwenden. Und wenn man die Einwanderung hinzurechnet, ist
Einwanderung Eigentum. Und wir werden angeben,
wo sich unsere Migrationen befinden. Also, weil Bandwürmer hier Ts Vice offensichtlich
nicht ausführen können. Wir werden also auf den Ordner dist verweisen ,
der
die GS-Migrationen, Fats, enthält. Also hier, das und dann die Quelle und dann im
Auswanderungsordner. Und dann führe alle Dateien aus, die
eine niederländische Migration haben gs sind und mit der Erweiterung
Punkt js enden. Ja, also lasst uns das speichern. Und eigentlich sind es keine Migrationen, sondern
Run-Button-Integrationen. Das war's. Wir werden den
Migrationslauf verwenden, um anzugeben, dass wir
alle Migrationen ausführen möchten , wenn
wir diesen Server betreiben. Also hier auf wahr gesetzt. Jetzt speichern wir das und schauen, dass unser
Server neu gestartet wird. In Ordnung,
versuchen wir jetzt, uns anzumelden. Und dieses Mal verwenden
wir nicht FirstName, sondern fügen nur
den Namen hinzu. Genau hier im
Sandkasten, Apollo-Sandkasten. Gehe zu einer Mutation und wähle
die Anmeldemutation aus. Also hier,
Anmeldemutation und
warte auf das JWT-Token oder die Eingaben. Und Sie können hier sehen, dass
wir die Grafikausrüstung aktualisiert haben, aber das bedeutet nicht, dass wir auch die Datenbank
aktualisiert haben. Aber
das werden wir in nur einer Minute überprüfen. Ja. Lassen Sie uns das
alles hier hinzufügen. Und lassen Sie mich das erweitern. In Ordnung, wähle eine beliebige E-Mail. E-Mail, email.com, LastName,
Benutzername, sagen wir John. Passwort. Passwort.
Melden wir uns an. Und wir sollten das JWT-Token bekommen. Wenn wir die Datenbank erfolgreich
aktualisiert haben
und das
erfolgreich getan haben, haben
wir hier das JWT-Token und wir haben einen Benutzer in unserer Datenbank mit
dem neuen Eigenschaftsnamen
anstelle von FirstName. Lassen Sie mich also annehmen, ob wir den Benutzer hierher
zurückgeben können, in Ordnung, wir können, also lassen Sie mich
all diese Felder zurückgeben. Und ich melde mich
mit einer anderen E-Mail an, vielleicht hat ein Benutzer eine, und das war's. Melden wir uns an. Los geht's. Wir haben hier
den Namenssatz FirstName. Deshalb haben wir
unsere Datenbank mithilfe
der Einwanderung erfolgreich aktualisiert . So können wir das also machen. Stellen Sie jedoch sicher, dass Sie
dies immer auf false setzen. Oder es kann es einfach von hier
entfernen. Ich werde es behalten,
nur um Sie daran zu erinnern , dass diese Eigenschaft falsch sein
muss. Und für die Einwanderungen müssen
wir immer GFS-Dateien
ausführen. Und Sie können im dist-Ordner
sehen, dass wir den
Einwanderungsordner haben . Hier
haben wir zwei Dateien für
die Einwanderung. Und das liegt daran, dass ich
diese API getestet habe und versucht habe, die Migration
auszuführen. Aber wenn wir mehrere Ebenen und
Migrationsdateien haben und
Sie sie hier löschen, heißt das nicht, dass
sie neben dem dist-Ordner
gelöscht werden . Stellen Sie also immer sicher, dass Sie
den dist-Ordner hier entfernen und stellen Sie sicher, dass Sie
jedes Mal, wenn Sie die API ausführen, einen neuen generieren . Andernfalls führen Sie alle Integrationsdateien und beschädigen
Ihre Datenbank. Und denken Sie auch daran, dasselbe zu
tun. Die Seite hier hat Einwanderungen entfernt , weil wir sie bereits
ausgeführt haben. Wenn Sie möchten, können
Sie
die Einwanderungsdateien jedoch an einem
anderen Ort aufbewahren . Ja. Nicht unbedingt. Seitlich des Projektordners. In diesem Fall können Sie
die Down-Methode verwenden , um die Einwanderung
rückgängig zu machen,
wenn Sie dies tun möchten. Ja. Für uns ist das also keine große
Sache, weil wir nur FirstName in Name ändern. Also werde ich
diesen ganzen Ordner löschen. Und das war's. Jetzt werden wir jedes Mal, wenn wir die Datenbank migrieren
wollen, eine neue Datei abrufen und sie von der
Type Around-Datenquelle aus ausführen. Bevor ich dieses Video beende, möchte
ich eine
Sache erwähnen: Wenn Sie die Migrationen
mit diesem Befehl ausführen
möchten , müssen
Sie die
Migrationseigenschaft in der
Datenquelle haben , oder? Und Sie können Immigrations Run hinzufügen oder es einfach von dort entfernen. Spielt es eine Rolle? Um diesen Befehl ausführen zu
können, müssen Sie jedoch über die Eigenschaft
immigrations verfügen und den Migrationsort
angeben. Und das war's.