API sans serveur GraphQL utilisant Kinvey Microservices

Voyons comment nous pouvons facilement utiliser Kinvey pour créer rapidement un microservice nous permettant de stocker, d’interroger et de mettre à jour le nom et l’âge de nos amis.

Progress Kinvey est une plate-forme d’application Haute productivité offrant un serveur sans serveur . Cloud backend pour la création rapide d'applications et d'expériences d'entreprise à l'échelle du consommateur. La productivité des développeurs est considérablement accrue grâce à des infrastructures frontales open source intégrées à un système à code réduit permettant des intégrations prêtes à l'emploi avec les systèmes d'entreprise et les systèmes existants.

Les services Kinvey Flex Services sont des noeuds légers et à code réduit. js microservices, utilisés pour les intégrations de données et la logique métier fonctionnelle. Les services Flex utilisent le SDK Flex et peuvent être constitués de FlexData pour les intégrations de données, de FlexFunctions pour les données basées sur des déclencheurs avant / après raccrochés ou personnalisés, et FlexAuth pour l'authentification personnalisée via Mobile Identity Connect (MIC) .

Les données sont un composant essentiel de nombreuses applications. En apparence, l'accès aux données semble simple: vous disposez d'un magasin pour vos données, qu'il s'agisse d'un SGBDR traditionnel d'un magasin NoSQL moderne ou d'un stockage local . . La réalité est cependant beaucoup plus complexe. L'abstraction de données fournie par la plate-forme Kinvey sert de cadre pour faire face à ces complexités en fournissant aux développeurs des outils qui simplifient le développement d'applications riches et orientées données. L'abstraction de données de base de Kinvey est la collection . Une collection est simplement un groupe d'entités de données liées. Kinvey ne fait aucune hypothèse sur la composition ou le schéma d'une collection (à l'exception de quelques propriétés système prédéfinies).

Si vous n'êtes toujours pas un client Kinvey, allez sur Kinvey Serverless Cloud Platform pour apprendre. à propos de toutes les possibilités. En outre, ce didacticiel suppose des connaissances relatives à SOA (architecture orientée service) et à l'interrogation / manipulation des données GraphQL .

Ce document décrit toutes les étapes, y compris la configuration d'un service Flex. localement, tout en veillant à ce que le service nécessaire soit configuré dans la console Kinvey – interface utilisateur de gestion d’arrière-plan de Kinvey. Vous devez avoir un compte Kinvey pour pouvoir suivre ces étapes. Si vous n'avez pas encore de compte, utilisez le lien suivant pour vous inscrire: https://console.kinvey.com/sign-up .

Le référentiel GitHub utilisé dans ce didacticiel est disponible à l'adresse suivante: https://github.com/bilger-progress/flex-graphql-article

Au cours des prochaines minutes, nous allons créer un microservice . ] qui nous aide à stocker les noms et les âges de nos amis. Il exposera une requête unique, qui peut nous révéler quel est l'âge de quelqu'un. Si aucun âge n'est défini pour cette personne, nous recevrons le message approprié à cet effet. Il y aura également une seule mutation que nous utiliserons pour définir (ou modifier) ​​l'âge d'une personne.

Console Kinvey

Commencez par créer une application Kinvey et un Flex. Service à l'aide de la console Kinvey .

Commencez par vous connecter à https://console.kinvey.com/ à l'aide de votre compte Kinvey et créez une nouvelle application. Nous appellerons la nôtre flex-graphql-article .

Une fois l'application créée, accédez à Services à partir de la barre de navigation supérieure et ajoutez un nouveau service de type Flex. avec le sous-type Exécution des services Flex . Donnez-lui un nom approprié tel que flex-graphql-article-service puis choisissez l'application que vous venez de créer pour lui donner accès au service. Étant donné que Kinvey Flex Services utilise les environnements dès que vous initialisez le service, vous devez enregistrer l'environnement (initial) généré automatiquement pour votre service . Utilisez l'image ci-dessous comme référence.

à l'aide de NPM ). Vous devrez installer deux dépendances à ce projet Node.js. Ce sont les suivants:

Le module graphql facilite la création rapide d'un service GraphQL validant les requêtes et les mutations. Le module kinvey-flex-sdk sera nécessaire pour initialiser et développer notre service flexible Kinvey . Vérifiez le référentiel pour connaître les versions requises de ces paquets.

Après avoir ajouté ces deux dépendances (paquets), créons un nouveau fichier JavaScript et appelez-le index.js. . Dans ce fichier, nous ajouterons le code de notre service Flex. Pour obtenir la version la plus récente du code, consultez l'adresse suivante: https://github.com/bilger-progress/flex-graphql-article/blob/master/flex-graphql-article/ index.js

Parlons du fonctionnement de ce code

Initialement, parce que le SDK Kinvey Flex utilise un modèle de rappel nous nous assurerons de promisify . ces exécutions de rappel. La fonction, que nous appellerons promisify () englobe les exécutions de rappel dans promesses .

 function promisify (func) {
 return (... args) => {
 renvoie une nouvelle promesse ((résoudre, rejeter) => {
 func (... arguments, (error, data) => {
 si (erreur) {
 renvoyer rejet (erreur) ; 
} 
 retour résoudre (données); 
}; 
}; 
}; 
} 

Après avoir compris cela, il est temps de poursuivre la mise en œuvre de deux fonctions qui serviront à gérer l’âge de nos amis. La première fonction, getAge () récupère tous les données utilisateur de la collection Kinvey et prépare le message correct en fonction de ces informations. La deuxième fonction, setAge () extrait également toutes les données utilisateur de la collection Kinvey, puis met à jour les champs nécessaires.

 function getAge (nom, contexte) {
 ] return fetchFriendData (nom, contexte) 
 .then ((data) => {
 if (! data ||! data.age) {
 return `Désolé. Vous n'avez pas encore défini l'âge de votre ami - $ {nom}. Vous pouvez le faire maintenant. » 
 .catch (erreur => logPromiseError (erreur, contexte)); 
}; 

 fonction setAge (nom, âge, contexte) {
 renvoie fetchFriendData (nom, contexte) 
 .then ( (data) => {
 const savePromisified = promisify (context.modules.dataStore (). collection (COLLECTION_NAME) .save); 
 if (! data) {
 renvoie savePromisified ({nom, age} ); 
} 
 data.age = age; 
 return savePromisified (data); 
}) 
 .then (data => data.age) 
 .catch (error => logPromiseError (error, context)); 
}; 

Afin de garder notre code propre, la récupération des données à partir du backend est effectuée sur une fonction distincte.

 function fetchFriendData (nom, contexte) {
 const findPromisified = promisify (context.modules.dataStore (). collection (COLLECTION_NAME) .find); 
 retourne findPromisified (new context.modules.Query (). equalTo (". nom ", nom)) 
 .then (data => data [0]); 
} 

Si vous regardez plus bas, vous verrez les schémas de la GraphQL interrogation et mutations . La requête sera connectée à la fonction getAge () tandis que la mutation utilisera la fonction setAge () .

 const schema = new GraphQLSchema ({[19459030)] requête: new GraphQLObjectType ({
 name: "RootQueryType", 
 champs: {
 getAge: {
 args: {name: {name: "name", tapez: new GraphQLNonNull (GraphQLString) }}, 
 type: GraphQLString, 
 resolvez (parent, arguments, contexte) {
 return getAge (nom_argument, contexte); 
} 
} 
} 
 }), 
 mutation: new GraphQLObjectType ({
 nom: "RootMutationType", 
 champs: {
 setAge: {
 arguments: {
 nom: {nom: "nom" , tapez: new GraphQLNonNull (GraphQLString)}, 
 age: {nom: "age", tapez: new GraphQLNonNull (GraphQLInt)} 
}, 
 type: GraphQLString, 
 resolvez (parent, arguments) , contexte) {
 renvoie setAge (args.name, args.age, contexte); 
} 
} 
} 
}) 
}); 

Enfin, nous effectuons l'initialisation du service flexible Kinvey. Il existe une seule fonction enregistrée appelée graphql () . Lors de l'exécution de cette fonction, un appel à la méthode exposée par le package graphql est déclenché en passant le schéma déjà déclaré et les paramètres de corps accompagnant la demande.

 flex. functions.register ("graphql", (contexte, complet, modules) => {
 / ** 
 * Les fonctions Flex étant exécutées dans différents contextes (environnements d'application), 
 * les informations contenues dans le "contexte" et "modules" peuvent 
 * différer. Ainsi, pour chaque demande GraphQL, le contexte de l'appel de fonction correspondant doit être préparé 
 *. 
 * / 
 const graphqlArguments = {
 schéma , 
 source: context.body.query, 
 contextValue: {flex, contexte, modules} 
; 
 // FIRE! 
 graphql (graphqlArguments) 
 .then (données => complete (). setBody (data) .ok (). next ()) 
 .catch (error => complete (). setBody (erreur) .runtimeError (). done ()) 
} ]; 

Kinvey CLI

Cool ! À ce stade, nous avons tout ce dont nous avons besoin pour exécuter un service Flex. Tout ce que nous avons à faire est de lier le projet Node.js au service Flex que nous avons créé avec Kinvey Console. Cette opération est effectuée à l'aide de l'utilitaire de ligne de commande Kinvey CLI que nous installerons ensuite. Ouvrez une fenêtre de terminal et tapez ce qui suit:

 npm install -g kinvey-cli 

Une fois l'installation terminée, ouvrez une fenêtre de terminal à l'intérieur du répertoire du projet et exécutez ce qui suit:

Utilisation les mêmes informations d'identification que celles que vous utilisez pour vous connecter à la console Kinvey lorsque vous y êtes invité. Vous devez également nommer le profil que Kinvey CLI va créer pour vous. Nous appellerons notre profil development car il se trouve sur notre ordinateur local. Si vous êtes un client Kinvey, vous avez peut-être une instance dédiée de Kinvey . Si tel est le cas, entrez le bon numéro d'instance . Si vous n'avez pas d'instance Kinvey dédiée, vous pouvez laisser cette option vide. On pourrait également vous poser des questions sur le jeton 2FA si l'authentification à deux facteurs a été activée pour votre compte.

développement de l’utilisation du profil kinvey