Création de requêtes de base (JavaScript) - AWS AppSync

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Création de requêtes de base (JavaScript)

Les résolveurs GraphQL connectent les champs d'un schéma de type à une source de données. Les résolveurs sont le mécanisme par lequel les demandes sont satisfaites.

Résolveurs AWS AppSync utilisés JavaScript pour convertir une expression GraphQL dans un format utilisable par la source de données. Les modèles de mappage peuvent également être écrits dans le langage de modèle Apache Velocity (VTL) pour convertir une expression GraphQL dans un format utilisable par la source de données.

Cette section décrit comment configurer les résolveurs à l'aide JavaScript de. La section Tutoriels sur les résolveurs (JavaScript) propose des didacticiels approfondis sur la façon d'implémenter des résolveurs à l'aide de. JavaScript La section Resolver reference (JavaScript) fournit une explication des opérations utilitaires qui peuvent être utilisées avec les JavaScript résolveurs.

Nous vous recommandons de suivre ce guide avant d'essayer d'utiliser l'un des didacticiels mentionnés ci-dessus.

Dans cette section, nous expliquerons comment créer et configurer des résolveurs pour les requêtes et les mutations.

Note

Ce guide part du principe que vous avez créé votre schéma et que vous avez au moins une requête ou une mutation. Si vous recherchez des abonnements (données en temps réel), consultez ce guide.

Dans cette section, nous allons fournir quelques étapes générales pour configurer les résolveurs, ainsi qu'un exemple utilisant le schéma ci-dessous :

// schema.graphql file input CreatePostInput { title: String date: AWSDateTime } type Post { id: ID! title: String date: AWSDateTime } type Mutation { createPost(input: CreatePostInput!): Post } type Query { getPost: [Post] }

Création de résolveurs de requêtes de base

Cette section explique comment créer un résolveur de requêtes de base.

Console
  1. Connectez-vous à la AppSyncconsole AWS Management Console et ouvrez-la.

    1. Dans le APIstableau de bord, choisissez votre GraphQLAPI.

    2. Dans la barre latérale, choisissez Schema.

  2. Entrez les détails de votre schéma et de votre source de données. Consultez les sections Conception de votre schéma et Attachement d'une source de données pour plus d'informations.

  3. À côté de l'éditeur de schéma, il y a une fenêtre appelée Resolvers. Cette zone contient une liste des types et des champs tels que définis dans votre fenêtre de schéma. Vous pouvez associer des résolveurs aux champs. Vous allez probablement associer des résolveurs à vos opérations sur le terrain. Dans cette section, nous allons examiner les configurations de requêtes simples. Sous le type de requête, choisissez Joindre à côté du champ de votre requête.

  4. Sur la page Attacher un résolveur, sous Type de résolveur, vous pouvez choisir entre des résolveurs de type pipeline ou unitaire. Pour plus d'informations sur ces types, consultez la section Résolveurs. Ce guide utiliserapipeline resolvers.

    Astuce

    Lorsque vous créez des résolveurs de pipeline, vos sources de données seront associées aux fonctions de pipeline. Les fonctions sont créées une fois que vous avez créé le résolveur de pipeline lui-même, c'est pourquoi il n'est pas possible de le définir dans cette page. Si vous utilisez un résolveur d'unités, la source de données est directement liée au résolveur. Vous devez donc la définir dans cette page.

    Pour le moteur d'exécution du résolveur, choisissez d'APPSYNC_JSactiver le JavaScript moteur d'exécution.

  5. Vous pouvez activer la mise en cache pour celaAPI. Nous vous recommandons de désactiver cette fonctionnalité pour le moment. Sélectionnez Create (Créer).

  6. Sur la page Modifier le résolveur, il existe un éditeur de code appelé Resolver code qui vous permet d'implémenter la logique du gestionnaire de résolution et de la réponse (avant et après les étapes). Pour plus d'informations, consultez la présentation des JavaScript résolveurs.

    Note

    Dans notre exemple, nous allons simplement laisser la demande vide et la réponse définie pour renvoyer le dernier résultat de la source de données à partir du contexte :

    import {util} from '@aws-appsync/utils'; export function request(ctx) { return {}; } export function response(ctx) { return ctx.prev.result; }

    Sous cette section, il y a un tableau appelé Fonctions. Les fonctions vous permettent d'implémenter du code qui peut être réutilisé dans plusieurs résolveurs. Au lieu de constamment réécrire ou copier le code, vous pouvez stocker le code source sous forme de fonction à ajouter à un résolveur chaque fois que vous en avez besoin.

    Les fonctions constituent l'essentiel de la liste des opérations d'un pipeline. Lorsque vous utilisez plusieurs fonctions dans un résolveur, vous définissez l'ordre des fonctions, et elles seront exécutées dans cet ordre de manière séquentielle. Ils sont exécutés après l'exécution de la fonction de demande et avant le début de la fonction de réponse.

    Pour ajouter une nouvelle fonction, sous Fonctions, choisissez Ajouter une fonction, puis Créer une nouvelle fonction. Vous pouvez également voir un bouton Créer une fonction pour choisir à la place.

    1. Choisissez une source de données. Il s'agira de la source de données sur laquelle le résolveur agira.

      Note

      Dans notre exemple, nous attachons un résolveur pourgetPost, qui récupère un Post objet par. id Supposons que nous ayons déjà configuré une table DynamoDB pour ce schéma. Sa clé de partition est définie sur id et est vide.

    2. Entrez unFunction name.

    3. Sous Code de fonction, vous devez implémenter le comportement de la fonction. Cela peut prêter à confusion, mais chaque fonction aura son propre gestionnaire de requêtes et de réponses local. La demande est exécutée, puis la source de données est invoquée pour traiter la demande, puis la réponse de la source de données est traitée par le gestionnaire de réponses. Le résultat est stocké dans l'objet de contexte. Ensuite, la fonction suivante de la liste s'exécutera ou sera transmise au gestionnaire de réponses après étape s'il s'agit de la dernière.

      Note

      Dans notre exemple, nous attachons un résolveur àgetPost, qui obtient une liste d'Postobjets à partir de la source de données. Notre fonction de requête demandera les données de notre table, la table transmettra sa réponse au contexte (ctx), puis la réponse renverra le résultat dans le contexte. AWS AppSync sa force réside dans son interconnexion avec les autres AWS services. Parce que nous utilisons DynamoDB, nous disposons d'une suite d'opérations pour simplifier ce type de choses. Nous avons également quelques exemples standard pour d'autres types de sources de données.

      Notre code ressemblera à ceci :

      import { util } from '@aws-appsync/utils'; /** * Performs a scan on the dynamodb data source */ export function request(ctx) { return { operation: 'Scan' }; } /** * return a list of scanned post items */ export function response(ctx) { return ctx.result.items; }

      Au cours de cette étape, nous avons ajouté deux fonctions :

      • request: Le gestionnaire de demandes effectue l'opération de récupération par rapport à la source de données. L'argument contient l'objet de contexte (ctx) ou certaines données accessibles à tous les résolveurs effectuant une opération particulière. Par exemple, il peut contenir des données d'autorisation, les noms de champs en cours de résolution, etc. L'instruction return exécute une Scanopération (voir ici pour des exemples). Comme nous travaillons avec DynamoDB, nous sommes autorisés à utiliser certaines des opérations de ce service. L'analyse effectue une extraction de base de tous les éléments de notre tableau. Le résultat de cette opération est stocké dans l'objet de contexte sous forme de result conteneur avant d'être transmis au gestionnaire de réponses. Le request est exécuté avant la réponse dans le pipeline.

      • response: le gestionnaire de réponses qui renvoie le résultat durequest. L'argument est l'objet de contexte mis à jour, et l'instruction de retour estctx.prev.result. À ce stade du guide, cette valeur ne vous est peut-être pas familière. ctxfait référence à l'objet de contexte. prevfait référence à l'opération précédente dans le pipeline, qui était la nôtrerequest. resultIl contient le ou les résultats du résolveur lorsqu'il se déplace dans le pipeline. Si vous mettez le tout ensemble, ctx.prev.result il renvoie le résultat de la dernière opération effectuée, à savoir le gestionnaire de demandes.

    4. Choisissez Créer une fois que vous avez terminé.

  7. De retour sur l'écran du résolveur, sous Fonctions, choisissez le menu déroulant Ajouter une fonction et ajoutez votre fonction à votre liste de fonctions.

  8. Choisissez Enregistrer pour mettre à jour le résolveur.

CLI

Pour ajouter votre fonction

  • Créez une fonction pour votre résolveur de pipeline à l'aide de la create-function commande.

    Vous devez entrer quelques paramètres pour cette commande particulière :

    1. Le api-id de votreAPI.

    2. Le name de la fonction dans la AWS AppSync console.

    3. Le data-source-name ou le nom de la source de données que la fonction utilisera. Il doit déjà être créé et lié à votre GraphQL API dans le AWS AppSync service.

    4. L'runtimeenvironnement ou le langage de la fonction. Car JavaScript le nom doit êtreAPPSYNC_JS, et le runtime,1.0.0.

    5. Les code gestionnaires de requêtes et de réponses de votre fonction. Bien que vous puissiez le saisir manuellement, il est beaucoup plus facile de l'ajouter à un fichier .txt (ou dans un format similaire), puis de le transmettre en tant qu'argument.

      Note

      Notre code de requête se trouvera dans un fichier transmis en argument :

      import { util } from '@aws-appsync/utils'; /** * Performs a scan on the dynamodb data source */ export function request(ctx) { return { operation: 'Scan' }; } /** * return a list of scanned post items */ export function response(ctx) { return ctx.result.items; }

    Un exemple de commande peut ressembler à ceci :

    aws appsync create-function \ --api-id abcdefghijklmnopqrstuvwxyz \ --name get_posts_func_1 \ --data-source-name table-for-posts \ --runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \ --code file://~/path/to/file/{filename}.{fileType}

    Une sortie sera renvoyée dans leCLI. Voici un exemple :

    { "functionConfiguration": { "functionId": "ejglgvmcabdn7lx75ref4qeig4", "functionArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/functions/ejglgvmcabdn7lx75ref4qeig4", "name": "get_posts_func_1", "dataSourceName": "table-for-posts", "maxBatchSize": 0, "runtime": { "name": "APPSYNC_JS", "runtimeVersion": "1.0.0" }, "code": "Code output goes here" } }
    Note

    Assurez-vous de l'enregistrer functionId quelque part car cela sera utilisé pour associer la fonction au résolveur.

Pour créer votre résolveur

  • Créez une fonction de pipeline pour Query en exécutant la create-resolver commande.

    Vous devez entrer quelques paramètres pour cette commande particulière :

    1. Le api-id de votreAPI.

    2. Le type-name ou le type d'objet spécial dans votre schéma (requête, mutation, abonnement).

    3. L'field-nameopération ou l'opération sur le terrain à l'intérieur du type d'objet spécial auquel vous souhaitez associer le résolveur.

    4. Lekind, qui spécifie un résolveur d'unité ou de pipeline. Définissez ce paramètre sur PIPELINE pour activer les fonctions de pipeline.

    5. La pipeline-config ou les fonctions à associer au résolveur. Assurez-vous de connaître les functionId valeurs de vos fonctions. L'ordre d'inscription est important.

    6. Leruntime, qui était APPSYNC_JS (JavaScript). L'est runtimeVersion actuellement1.0.0.

    7. Lecode, qui contient les gestionnaires d'étapes avant et après.

      Note

      Notre code de requête se trouvera dans un fichier transmis en argument :

      import { util } from '@aws-appsync/utils'; /** * Sends a request to `put` an item in the DynamoDB data source */ export function request(ctx) { const { id, ...values } = ctx.args; return { operation: 'PutItem', key: util.dynamodb.toMapValues({ id }), attributeValues: util.dynamodb.toMapValues(values), }; } /** * returns the result of the `put` operation */ export function response(ctx) { return ctx.result; }

    Un exemple de commande peut ressembler à ceci :

    aws appsync create-resolver \ --api-id abcdefghijklmnopqrstuvwxyz \ --type-name Query \ --field-name getPost \ --kind PIPELINE \ --pipeline-config functions=ejglgvmcabdn7lx75ref4qeig4 \ --runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \ --code file:///path/to/file/{filename}.{fileType}

    Une sortie sera renvoyée dans leCLI. Voici un exemple :

    { "resolver": { "typeName": "Mutation", "fieldName": "getPost", "resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Mutation/resolvers/getPost", "kind": "PIPELINE", "pipelineConfig": { "functions": [ "ejglgvmcabdn7lx75ref4qeig4" ] }, "maxBatchSize": 0, "runtime": { "name": "APPSYNC_JS", "runtimeVersion": "1.0.0" }, "code": "Code output goes here" } }
CDK
Astuce

Avant de l'utiliserCDK, nous vous recommandons CDK de consulter la documentation officielle ainsi que AWS AppSync les CDKréférences.

Les étapes répertoriées ci-dessous ne montreront qu'un exemple général de l'extrait de code utilisé pour ajouter une ressource particulière. Cela n'est pas censé être une solution fonctionnelle dans votre code de production. Nous partons également du principe que vous disposez déjà d'une application fonctionnelle.

Une application de base nécessite les éléments suivants :

  1. Directives d'importation de services

  2. Code de schéma

  3. Générateur de sources de données

  4. Code de fonction

  5. Code du résolveur

Dans les sections Conception de votre schéma et Attachement d'une source de données, nous savons que le fichier de pile inclura les directives d'importation du formulaire :

import * as x from 'x'; # import wildcard as the 'x' keyword from 'x-service' import {a, b, ...} from 'c'; # import {specific constructs} from 'c-service'
Note

Dans les sections précédentes, nous avons uniquement indiqué comment importer des AWS AppSync constructions. Dans le code réel, vous devrez importer davantage de services juste pour exécuter l'application. Dans notre exemple, si nous devions créer une CDK application très simple, nous importerions au moins le AWS AppSync service avec notre source de données, qui était une table DynamoDB. Nous aurions également besoin d'importer des constructions supplémentaires pour déployer l'application :

import * as cdk from 'aws-cdk-lib'; import * as appsync from 'aws-cdk-lib/aws-appsync'; import * as dynamodb from 'aws-cdk-lib/aws-dynamodb'; import { Construct } from 'constructs';

Pour résumer chacune d'entre elles :

  • import * as cdk from 'aws-cdk-lib';: Cela vous permet de définir votre CDK application et des constructions telles que la pile. Il contient également des fonctions utilitaires utiles pour notre application, telles que la manipulation des métadonnées. Si vous connaissez cette directive d'importation, mais que vous vous demandez pourquoi la bibliothèque principale cdk n'est pas utilisée ici, consultez la page de migration.

  • import * as appsync from 'aws-cdk-lib/aws-appsync';: Ceci importe le AWS AppSync service.

  • import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';: Ceci importe le service DynamoDB.

  • import { Construct } from 'constructs';: Nous en avons besoin pour définir la construction racine.

Le type d'importation dépend des services que vous appelez. Nous vous recommandons de consulter la CDK documentation pour obtenir des exemples. Le schéma en haut de la page sera un fichier distinct dans votre CDK application sous forme de .graphql fichier. Dans le fichier de pile, nous pouvons l'associer à un nouveau GraphQL en utilisant le formulaire :

const add_api = new appsync.GraphqlApi(this, 'graphQL-example', { name: 'my-first-api', schema: appsync.SchemaFile.fromAsset(path.join(__dirname, 'schema.graphql')), });
Note

Dans le cadre de add_api ce projet, nous ajoutons un nouveau GraphQL API en utilisant le new mot clé suivi de. appsync.GraphqlApi(scope: Construct, id: string , props: GraphqlApiProps) Notre champ d'application estthis, l'CFNidentifiant estgraphQL-example, et nos accessoires sont my-first-api (nom du API dans la console) et schema.graphql (le chemin absolu vers le fichier de schéma).

Pour ajouter une source de données, vous devez d'abord ajouter votre source de données à la pile. Ensuite, vous devez l'associer au GraphQL en API utilisant la méthode spécifique à la source. L'association se produira lorsque vous ferez fonctionner votre résolveur. En attendant, prenons un exemple en créant la table DynamoDB en utilisant : dynamodb.Table

const add_ddb_table = new dynamodb.Table(this, 'posts-table', { partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING, }, });
Note

Si nous devions l'utiliser dans notre exemple, nous ajouterions une nouvelle table DynamoDB avec CFN l'identifiant et la clé posts-table de partition de. id (S)

Ensuite, nous devons implémenter notre résolveur dans le fichier de pile. Voici un exemple de requête simple qui recherche tous les éléments d'une table DynamoDB :

const add_func = new appsync.AppsyncFunction(this, 'func-get-posts', { name: 'get_posts_func_1', add_api, dataSource: add_api.addDynamoDbDataSource('table-for-posts', add_ddb_table), code: appsync.Code.fromInline(` export function request(ctx) { return { operation: 'Scan' }; } export function response(ctx) { return ctx.result.items; } `), runtime: appsync.FunctionRuntime.JS_1_0_0, }); new appsync.Resolver(this, 'pipeline-resolver-get-posts', { add_api, typeName: 'Query', fieldName: 'getPost', code: appsync.Code.fromInline(` export function request(ctx) { return {}; } export function response(ctx) { return ctx.prev.result; } `), runtime: appsync.FunctionRuntime.JS_1_0_0, pipelineConfig: [add_func], });
Note

Tout d'abord, nous avons créé une fonction appeléeadd_func. Cet ordre de création peut sembler un peu paradoxal, mais vous devez créer les fonctions dans votre résolveur de pipeline avant de créer le résolveur lui-même. Une fonction se présente sous la forme suivante :

AppsyncFunction(scope: Construct, id: string, props: AppsyncFunctionProps)

Notre champ d'application étaitthis, notre CFN identifiant l'étaitfunc-get-posts, et nos accessoires contenaient les détails de la fonction réelle. À l'intérieur des accessoires, nous avons inclus :

  • La name fonction qui sera présente dans la AWS AppSync console (get_posts_func_1).

  • Le GraphQL API que nous avons créé précédemment ()add_api.

  • La source de données ; c'est le point où nous lions la source de données à la API valeur GraphQL, puis nous l'attachons à la fonction. Nous prenons la table que nous avons créée (add_ddb_table) et l'attachons au GraphQL API (add_api) en utilisant l'une des GraphqlApi méthodes (addDynamoDbDataSource). La valeur id (table-for-posts) est le nom de la source de données dans la AWS AppSync console. Pour obtenir la liste des méthodes spécifiques à la source, consultez les pages suivantes :

  • Le code contient les gestionnaires de demandes et de réponses de notre fonction, à savoir un simple scan et un retour.

  • Le runtime indique que nous voulons utiliser le runtime APPSYNC _JS version 1.0.0. Notez qu'il s'agit actuellement de la seule version disponible pour APPSYNC _JS.

Ensuite, nous devons associer la fonction au résolveur de pipeline. Nous avons créé notre résolveur en utilisant le formulaire :

Resolver(scope: Construct, id: string, props: ResolverProps)

Notre champ d'application étaitthis, notre CFN identifiant l'étaitpipeline-resolver-get-posts, et nos accessoires contenaient les détails de la fonction réelle. À l'intérieur des accessoires, nous avons inclus :

  • Le GraphQL API que nous avons créé précédemment ()add_api.

  • Le nom du type d'objet spécial ; il s'agit d'une opération de requête, nous avons donc simplement ajouté la valeurQuery.

  • Le nom du champ (getPost) est le nom du champ dans le schéma sous le Query type.

  • Le code contient vos gestionnaires avant et après. Notre exemple renvoie simplement les résultats qui se trouvaient dans le contexte une fois que la fonction a effectué son opération.

  • Le runtime indique que nous voulons utiliser le runtime APPSYNC _JS version 1.0.0. Notez qu'il s'agit actuellement de la seule version disponible pour APPSYNC _JS.

  • La configuration du pipeline contient la référence à la fonction que nous avons créée (add_func).

Pour résumer ce qui s'est passé dans cet exemple, vous avez vu une AWS AppSync fonction implémentant un gestionnaire de requêtes et de réponses. La fonction était chargée d'interagir avec votre source de données. Le gestionnaire de demandes a envoyé une Scan opération à AWS AppSync, lui indiquant quelle opération effectuer sur votre source de données DynamoDB. Le gestionnaire de réponses a renvoyé la liste des éléments (ctx.result.items). La liste des éléments a ensuite été automatiquement mappée au type Post GraphQL.

Création de résolveurs de mutations de base

Cette section vous montrera comment créer un résolveur de mutations de base.

Console
  1. Connectez-vous à la AppSyncconsole AWS Management Console et ouvrez-la.

    1. Dans le APIstableau de bord, choisissez votre GraphQLAPI.

    2. Dans la barre latérale, choisissez Schema.

  2. Dans la section Résolveurs et dans le type de mutation, choisissez Attacher à côté de votre champ.

    Note

    Dans notre exemple, nous attachons un résolveur pourcreatePost, qui ajoute un Post objet à notre tableau. Supposons que nous utilisions la même table DynamoDB que celle de la section précédente. Sa clé de partition est définie sur id et est vide.

  3. Sur la page Joindre un résolveur, sous Type de résolveur, sélectionnez. pipeline resolvers Pour rappel, vous trouverez plus d'informations sur les résolveurs ici. Pour le moteur d'exécution du résolveur, choisissez d'APPSYNC_JSactiver le JavaScript moteur d'exécution.

  4. Vous pouvez activer la mise en cache pour celaAPI. Nous vous recommandons de désactiver cette fonctionnalité pour le moment. Sélectionnez Create (Créer).

  5. Choisissez Ajouter une fonction, puis Créer une nouvelle fonction. Vous pouvez également voir un bouton Créer une fonction pour choisir à la place.

    1. Choisissez votre source de données . Il doit s'agir de la source dont vous allez manipuler les données avec la mutation.

    2. Entrez unFunction name.

    3. Sous Code de fonction, vous devez implémenter le comportement de la fonction. Comme il s'agit d'une mutation, la demande effectuera idéalement une opération de changement d'état sur la source de données invoquée. Le résultat sera traité par la fonction de réponse.

      Note

      createPostc'est ajouter, ou « mettre », un nouveau Post dans le tableau avec nos paramètres comme données. Nous pourrions ajouter quelque chose comme ceci :

      import { util } from '@aws-appsync/utils'; /** * Sends a request to `put` an item in the DynamoDB data source */ export function request(ctx) { return { operation: 'PutItem', key: util.dynamodb.toMapValues({id: util.autoId()}), attributeValues: util.dynamodb.toMapValues(ctx.args.input), }; } /** * returns the result of the `put` operation */ export function response(ctx) { return ctx.result; }

      Au cours de cette étape, nous avons également ajouté request des response fonctionnalités :

      • request: Le gestionnaire de requêtes accepte le contexte comme argument. L'instruction return du gestionnaire de requêtes exécute une PutItemcommande, qui est une opération DynamoDB intégrée (voir ici ou ici pour des exemples). La PutItem commande ajoute un Post objet à notre table DynamoDB en prenant la valeur de la key partition (générée automatiquement util.autoid() par) attributes et à partir de l'argument de contexte saisi (ce sont les valeurs que nous transmettrons dans notre demande). Les arguments du title champ key est id date et attributes sont le et. Ils sont tous deux préformatés via l'util.dynamodb.toMapValuesassistant pour fonctionner avec la table DynamoDB.

      • response: La réponse accepte le contexte mis à jour et renvoie le résultat du gestionnaire de demandes.

    4. Choisissez Créer une fois que vous avez terminé.

  6. De retour sur l'écran du résolveur, sous Fonctions, choisissez le menu déroulant Ajouter une fonction et ajoutez votre fonction à votre liste de fonctions.

  7. Choisissez Enregistrer pour mettre à jour le résolveur.

CLI

Pour ajouter votre fonction

  • Créez une fonction pour votre résolveur de pipeline à l'aide de la create-function commande.

    Vous devez entrer quelques paramètres pour cette commande particulière :

    1. Le api-id de votreAPI.

    2. Le name de la fonction dans la AWS AppSync console.

    3. Le data-source-name ou le nom de la source de données que la fonction utilisera. Il doit déjà être créé et lié à votre GraphQL API dans le AWS AppSync service.

    4. L'runtimeenvironnement ou le langage de la fonction. Car JavaScript le nom doit êtreAPPSYNC_JS, et le runtime,1.0.0.

    5. Les code gestionnaires de requêtes et de réponses de votre fonction. Bien que vous puissiez le saisir manuellement, il est beaucoup plus facile de l'ajouter à un fichier .txt (ou dans un format similaire) puis de le transmettre comme argument.

      Note

      Notre code de requête se trouvera dans un fichier transmis en argument :

      import { util } from '@aws-appsync/utils'; /** * Sends a request to `put` an item in the DynamoDB data source */ export function request(ctx) { return { operation: 'PutItem', key: util.dynamodb.toMapValues({id: util.autoId()}), attributeValues: util.dynamodb.toMapValues(ctx.args.input), }; } /** * returns the result of the `put` operation */ export function response(ctx) { return ctx.result; }

    Un exemple de commande peut ressembler à ceci :

    aws appsync create-function \ --api-id abcdefghijklmnopqrstuvwxyz \ --name add_posts_func_1 \ --data-source-name table-for-posts \ --runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \ --code file:///path/to/file/{filename}.{fileType}

    Une sortie sera renvoyée dans leCLI. Voici un exemple :

    { "functionConfiguration": { "functionId": "vulcmbfcxffiram63psb4dduoa", "functionArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/functions/vulcmbfcxffiram63psb4dduoa", "name": "add_posts_func_1", "dataSourceName": "table-for-posts", "maxBatchSize": 0, "runtime": { "name": "APPSYNC_JS", "runtimeVersion": "1.0.0" }, "code": "Code output foes here" } }
    Note

    Assurez-vous de l'enregistrer functionId quelque part car cela sera utilisé pour associer la fonction au résolveur.

Pour créer votre résolveur

  • Créez une fonction de pipeline pour Mutation en exécutant la create-resolver commande.

    Vous devez entrer quelques paramètres pour cette commande particulière :

    1. Le api-id de votreAPI.

    2. Le type-name ou le type d'objet spécial dans votre schéma (requête, mutation, abonnement).

    3. L'field-nameopération ou l'opération sur le terrain à l'intérieur du type d'objet spécial auquel vous souhaitez associer le résolveur.

    4. Lekind, qui spécifie un résolveur d'unité ou de pipeline. Définissez ce paramètre sur PIPELINE pour activer les fonctions de pipeline.

    5. La pipeline-config ou les fonctions à associer au résolveur. Assurez-vous de connaître les functionId valeurs de vos fonctions. L'ordre d'inscription est important.

    6. Leruntime, qui était APPSYNC_JS (JavaScript). L'est runtimeVersion actuellement1.0.0.

    7. Lecode, qui contient les étapes avant et après.

      Note

      Notre code de requête se trouvera dans un fichier transmis en argument :

      import { util } from '@aws-appsync/utils'; /** * Sends a request to `put` an item in the DynamoDB data source */ export function request(ctx) { const { id, ...values } = ctx.args; return { operation: 'PutItem', key: util.dynamodb.toMapValues({ id }), attributeValues: util.dynamodb.toMapValues(values), }; } /** * returns the result of the `put` operation */ export function response(ctx) { return ctx.result; }

    Un exemple de commande peut ressembler à ceci :

    aws appsync create-resolver \ --api-id abcdefghijklmnopqrstuvwxyz \ --type-name Mutation \ --field-name createPost \ --kind PIPELINE \ --pipeline-config functions=vulcmbfcxffiram63psb4dduoa \ --runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \ --code file:///path/to/file/{filename}.{fileType}

    Une sortie sera renvoyée dans leCLI. Voici un exemple :

    { "resolver": { "typeName": "Mutation", "fieldName": "createPost", "resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Mutation/resolvers/createPost", "kind": "PIPELINE", "pipelineConfig": { "functions": [ "vulcmbfcxffiram63psb4dduoa" ] }, "maxBatchSize": 0, "runtime": { "name": "APPSYNC_JS", "runtimeVersion": "1.0.0" }, "code": "Code output goes here" } }
CDK
Astuce

Avant de l'utiliserCDK, nous vous recommandons CDK de consulter la documentation officielle ainsi que AWS AppSync les CDKréférences.

Les étapes répertoriées ci-dessous ne montreront qu'un exemple général de l'extrait de code utilisé pour ajouter une ressource particulière. Cela n'est pas censé être une solution fonctionnelle dans votre code de production. Nous partons également du principe que vous disposez déjà d'une application fonctionnelle.

  • Pour effectuer une mutation, en supposant que vous participez au même projet, vous pouvez l'ajouter au fichier de pile comme dans la requête. Voici une fonction modifiée et un résolveur pour une mutation qui ajoute un nouveau élément Post à la table :

    const add_func_2 = new appsync.AppsyncFunction(this, 'func-add-post', { name: 'add_posts_func_1', add_api, dataSource: add_api.addDynamoDbDataSource('table-for-posts-2', add_ddb_table), code: appsync.Code.fromInline(` export function request(ctx) { return { operation: 'PutItem', key: util.dynamodb.toMapValues({id: util.autoId()}), attributeValues: util.dynamodb.toMapValues(ctx.args.input), }; } export function response(ctx) { return ctx.result; } `), runtime: appsync.FunctionRuntime.JS_1_0_0, }); new appsync.Resolver(this, 'pipeline-resolver-create-posts', { add_api, typeName: 'Mutation', fieldName: 'createPost', code: appsync.Code.fromInline(` export function request(ctx) { return {}; } export function response(ctx) { return ctx.prev.result; } `), runtime: appsync.FunctionRuntime.JS_1_0_0, pipelineConfig: [add_func_2], });
    Note

    Comme cette mutation et la requête sont structurées de la même manière, nous allons simplement expliquer les modifications que nous avons apportées pour effectuer la mutation.

    Dans la fonction, nous avons changé l'CFNidentifiant func-add-post et le nom add_posts_func_1 pour refléter le fait que nous ajoutons Posts à la table. Dans la source de données, nous avons créé une nouvelle association avec notre table (add_ddb_table) dans la AWS AppSync console, table-for-posts-2 car la addDynamoDbDataSource méthode l'exige. N'oubliez pas que cette nouvelle association utilise toujours la même table que celle que nous avons créée précédemment, mais que nous disposons désormais de deux connexions dans la AWS AppSync console : une pour la requête as table-for-posts et une pour la mutation astable-for-posts-2. Le code a été modifié pour ajouter un Post en générant sa id valeur automatiquement et en acceptant les entrées d'un client pour le reste des champs.

    Dans le résolveur, nous avons modifié la valeur de l'identifiant pipeline-resolver-create-posts pour refléter le fait que nous ajoutons Posts à la table. Pour refléter la mutation dans le schéma, le nom du type a été changé enMutation, et le nom,createPost. La configuration du pipeline a été définie sur notre nouvelle fonction de mutationadd_func_2.

Pour résumer ce qui se passe dans cet exemple, convertit AWS AppSync automatiquement les arguments définis dans le createPost champ à partir de votre schéma GraphQL en opérations DynamoDB. L'exemple stocke les enregistrements dans DynamoDB à l'aide d'une clé id de, qui est automatiquement créée à l'aide de notre assistant. util.autoId() Tous les autres champs que vous transmettez aux arguments de contexte (ctx.args.input) à partir de requêtes effectuées dans la AWS AppSync console ou autrement seront stockés en tant qu'attributs de la table. La clé et les attributs sont automatiquement mappés dans un format DynamoDB compatible à l'aide de l'assistant. util.dynamodb.toMapValues(values)

AWS AppSync prend également en charge les flux de travail de test et de débogage pour l'édition de résolveurs. Vous pouvez utiliser un context objet fictif pour voir la valeur transformée du modèle avant de l'invoquer. Vous pouvez éventuellement consulter la demande complète adressée à une source de données de manière interactive lorsque vous exécutez une requête. Pour plus d'informations, voir Tester et déboguer les résolveurs (JavaScript) et Surveillance et journalisation.

Résolveurs avancés

Si vous suivez la section facultative de pagination de la section Conception de votre schéma, vous devez tout de même ajouter votre résolveur à votre demande pour utiliser la pagination. Notre exemple a utilisé une pagination de requête appelée getPosts pour renvoyer uniquement une partie des éléments demandés à la fois. Le code de notre résolveur sur ce champ peut ressembler à ceci :

/** * Performs a scan on the dynamodb data source */ export function request(ctx) { const { limit = 20, nextToken } = ctx.args; return { operation: 'Scan', limit, nextToken }; } /** * @returns the result of the `put` operation */ export function response(ctx) { const { items: posts = [], nextToken } = ctx.result; return { posts, nextToken }; }

Dans la demande, nous transmettons le contexte de la demande. Notre limit est 20, ce qui signifie que nous renvoyons jusqu'à 20 Posts dans la première requête. Notre nextToken curseur est fixé sur la première Post entrée de la source de données. Ils sont transmis aux args. La demande effectue ensuite un scan depuis le premier Post jusqu'au nombre limite de scan. La source de données stocke le résultat dans le contexte, qui est transmis à la réponse. La réponse renvoie Posts le résultat récupéré, puis définit le nextToken is set sur l'Postentrée juste après la limite. La demande suivante est envoyée pour faire exactement la même chose, mais en commençant par le décalage juste après la première requête. N'oubliez pas que ces types de demandes sont effectués de manière séquentielle et non en parallèle.