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. # Modules intégrés Les modules font partie de l'`APPSYNC_JS`environnement d'exécution et fournissent des utilitaires pour aider à écrire des JavaScript résolveurs et des fonctions. Pour des exemples et des exemples, consultez le [aws-appsync-resolver-samples](https://github.com/aws-samples/aws-appsync-resolver-samples) GitHub référentiel. ## Fonctions du module DynamoDB Les fonctions du module DynamoDB offrent une expérience améliorée lors de l'interaction avec les sources de données DynamoDB. Vous pouvez envoyer des requêtes à vos sources de données DynamoDB à l'aide des fonctions et sans ajouter de mappage de type. Les modules sont importés à l'aide de `@aws-appsync/utils/dynamodb` : ``` // Modules are imported using @aws-appsync/utils/dynamodb import * as ddb from '@aws-appsync/utils/dynamodb'; ``` ### Fonctions #### Liste des fonctions **` get(payload: GetInput): DynamoDBGetItemRequest`** Voir [Inputs](#built-in-ddb-modules-inputs) pour plus d'informations sur GetInput. Génère un `DynamoDBGetItemRequest` objet pour envoyer une [GetItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-getitem)requête à DynamoDB. ``` import { get } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { return get({ key: { id: ctx.args.id } }); } ``` **`put(payload): DynamoDBPutItemRequest`** Génère un `DynamoDBPutItemRequest` objet pour envoyer une [PutItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem)requête à DynamoDB. ``` import * as ddb from '@aws-appsync/utils/dynamodb' export function request(ctx) { return ddb.put({ key: { id: util.autoId() }, item: ctx.args }); } ``` **`remove(payload): DynamoDBDeleteItemRequest`** Génère un `DynamoDBDeleteItemRequest` objet pour envoyer une [DeleteItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-deleteitem)requête à DynamoDB. ``` import * as ddb from '@aws-appsync/utils/dynamodb'; export function request(ctx) { return ddb.remove({ key: { id: ctx.args.id } }); } ``` **`scan(payload): DynamoDBScanRequest`** Génère un `DynamoDBScanRequest` pour envoyer une demande de [scan](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan) à DynamoDB. ``` import * as ddb from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const { limit = 10, nextToken } = ctx.args; return ddb.scan({ limit, nextToken }); } ``` **`sync(payload): DynamoDBSyncRequest`** Génère un `DynamoDBSyncRequest` objet pour effectuer une demande de [synchronisation](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-sync). La demande ne reçoit que les données modifiées depuis la dernière requête (mises à jour delta). Les demandes peuvent uniquement être adressées à des sources de données DynamoDB versionnées. ``` import * as ddb from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const { limit = 10, nextToken, lastSync } = ctx.args; return ddb.sync({ limit, nextToken, lastSync }); } ``` **`update(payload): DynamoDBUpdateItemRequest`** Génère un `DynamoDBUpdateItemRequest` objet pour envoyer une [UpdateItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-updateitem)requête à DynamoDB. ### Opérations Les aides aux opérations vous permettent d'effectuer des actions spécifiques sur certaines parties de vos données lors des mises à jour. Pour commencer, importez `operations` depuis `@aws-appsync/utils/dynamodb` : ``` // Modules are imported using operations import {operations} from '@aws-appsync/utils/dynamodb'; ``` #### Liste des opérations **`add(payload)`** Fonction d'assistance qui ajoute un nouvel élément d'attribut lors de la mise à jour de DynamoDB. **Exemple** Pour ajouter une adresse (rue, ville et code postal) à un élément DynamoDB existant à l'aide de la valeur ID : ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const updateObj = { address: operations.add({ street1: '123 Main St', city: 'New York', zip: '10001', }), }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`append (payload)`** Fonction d'assistance qui ajoute une charge utile à la liste existante dans DynamoDB. **Exemple** Pour ajouter un ami IDs (`newFriendIds`) récemment ajouté à une liste d'amis existante (`friendsIds`) lors d'une mise à jour : ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const newFriendIds = [101, 104, 111]; const updateObj = { friendsIds: operations.append(newFriendIds), }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`decrement (by?)`** Fonction d'assistance qui décrémente la valeur d'attribut existante dans l'élément lors de la mise à jour de DynamoDB. **Exemple** Pour réduire le compteur (`friendsCount`) d'un ami de 10 : ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const updateObj = { friendsCount: operations.decrement(10), }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`increment (by?)`** Fonction d'assistance qui incrémente la valeur d'attribut existante dans l'élément lors de la mise à jour de DynamoDB. **Exemple** Pour augmenter de 10 le compteur d'amis (`friendsCount`) : ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const updateObj = { friendsCount: operations.increment(10), }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`prepend (payload)`** Fonction d'assistance qui ajoute un préfixe à la liste existante dans DynamoDB. **Exemple** Pour ajouter un nouvel ami IDs (`newFriendIds`) à une liste d'amis existante (`friendsIds`) lors d'une mise à jour : ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const newFriendIds = [101, 104, 111]; const updateObj = { friendsIds: operations.prepend(newFriendIds), }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`replace (payload)`** Fonction d'assistance qui remplace un attribut existant lors de la mise à jour d'un élément dans DynamoDB. Cela est utile lorsque vous souhaitez mettre à jour l'intégralité de l'objet ou du sous-objet de l'attribut et pas uniquement les clés de la charge utile. **Exemple** Pour remplacer une adresse (rue, ville et code postal) dans un `info` objet : ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const updateObj = { info: { address: operations.replace({ street1: '123 Main St', city: 'New York', zip: '10001', }), }, }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`updateListItem (payload, index)`** Fonction d'assistance qui remplace un élément d'une liste. **Exemple** Dans le cadre de la mise à jour (`newFriendIds`), cet exemple a `updateListItem` été utilisé pour mettre à jour les valeurs d'ID du deuxième élément (index :`1`, new ID :`102`) et du troisième élément (index :`2`, new ID :`112`) dans une liste (`friendsIds`). ``` import { update, operations as ops } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const newFriendIds = [ ops.updateListItem('102', 1), ops.updateListItem('112', 2) ]; const updateObj = { friendsIds: newFriendIds }; return update({ key: { id: 1 }, update: updateObj }); } ``` ### Inputs #### Liste des entrées **`Type GetInput`** ``` GetInput: { consistentRead?: boolean; key: DynamoDBKey; } ``` **Déclaration de type** + `consistentRead?: boolean` (facultatif) Un booléen facultatif qui indique si vous souhaitez effectuer une lecture très cohérente avec DynamoDB. + `key: DynamoDBKey` (obligatoire) Paramètre obligatoire qui spécifie la clé de l'élément dans DynamoDB. Les éléments DynamoDB peuvent avoir une seule clé de hachage ou des clés de hachage et de tri. **`Type PutInput`** ``` PutInput: { _version?: number; condition?: DynamoDBFilterObject | null; customPartitionKey?: string; item: Partial; key: DynamoDBKey; populateIndexFields?: boolean; } ``` **Déclaration de type** + `_version?: number` (facultatif) + `condition?: DynamoDBFilterObject | null` (facultatif) Lorsque vous placez un objet dans une table DynamoDB, vous pouvez éventuellement spécifier une expression conditionnelle qui détermine si la demande doit aboutir ou non en fonction de l'état de l'objet déjà présent dans DynamoDB avant l'exécution de l'opération. + `customPartitionKey?: string` (facultatif) Lorsqu'elle est activée, cette valeur de chaîne modifie le format des `ds_pk` enregistrements `ds_sk` et utilisés par la table de synchronisation delta lorsque le versionnement est activé. Lorsque cette option est activée, le traitement de l'`populateIndexFields`entrée est également activé. + `item: Partial` (obligatoire) Le reste des attributs de l'élément à placer dans DynamoDB. + `key: DynamoDBKey` (obligatoire) Paramètre obligatoire qui spécifie la clé de l'élément dans DynamoDB sur lequel le placement sera effectué. Les éléments DynamoDB peuvent avoir une seule clé de hachage ou des clés de hachage et de tri. + `populateIndexFields?: boolean` (facultatif) Valeur booléenne qui, lorsqu'elle est activée en même temps que le`customPartitionKey`, crée de nouvelles entrées pour chaque enregistrement de la table de synchronisation delta, en particulier dans les colonnes `gsi_ds_pk` et`gsi_ds_sk`. Pour plus d'informations, consultez la section [Détection et synchronisation des conflits](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) dans le *manuel du AWS AppSync développeur*. **`Type QueryInput`** ``` QueryInput: ScanInput & { query: DynamoDBKeyCondition>; } ``` **Déclaration de type** + `query: DynamoDBKeyCondition>` (obligatoire) Spécifie une condition clé qui décrit les éléments à interroger. Pour un index donné, la condition d'une clé de partition doit être une égalité et la clé de tri une comparaison ou un `beginsWith` (lorsqu'il s'agit d'une chaîne). Seuls les types de nombres et de chaînes sont pris en charge pour les clés de partition et de tri. **Exemple** Prenez le `User` type ci-dessous : ``` type User = { id: string; name: string; age: number; isVerified: boolean; friendsIds: string[] } ``` La requête ne peut inclure que les champs suivants : `id``name`, et `age` : ``` const query: QueryInput = { name: { eq: 'John' }, age: { gt: 20 }, } ``` **`Type RemoveInput`** ``` RemoveInput: { _version?: number; condition?: DynamoDBFilterObject; customPartitionKey?: string; key: DynamoDBKey; populateIndexFields?: boolean; } ``` **Déclaration de type** + `_version?: number` (facultatif) + `condition?: DynamoDBFilterObject` (facultatif) Lorsque vous supprimez un objet dans DynamoDB, vous pouvez éventuellement spécifier une expression conditionnelle qui détermine si la demande doit aboutir ou non en fonction de l'état de l'objet déjà présent dans DynamoDB avant l'exécution de l'opération. **Exemple** L'exemple suivant est une `DeleteItem` expression contenant une condition qui permet à l'opération de réussir uniquement si le propriétaire du document correspond à l'utilisateur qui fait la demande. ``` type Task = { id: string; title: string; description: string; owner: string; isComplete: boolean; } const condition: DynamoDBFilterObject = { owner: { eq: 'XXXXXXXXXXXXXXXX' }, } remove({ key: { id: 'XXXXXXXXXXXXXXXX', }, condition, }); ``` + `customPartitionKey?: string` (facultatif) Lorsqu'elle est activée, la `customPartitionKey` valeur modifie le format des `ds_pk` enregistrements `ds_sk` et utilisés par la table de synchronisation delta lorsque le versionnement est activé. Lorsque cette option est activée, le traitement de l'`populateIndexFields`entrée est également activé. + `key: DynamoDBKey` (obligatoire) Paramètre obligatoire qui spécifie la clé de l'élément en cours de suppression dans DynamoDB. Les éléments DynamoDB peuvent avoir une seule clé de hachage ou des clés de hachage et de tri. **Exemple** Si a `User` uniquement la clé de hachage d'un utilisateur`id`, la clé ressemblera à ceci : ``` type User = { id: number name: string age: number isVerified: boolean } const key: DynamoDBKey = { id: 1, } ``` Si l'utilisateur de la table possède une clé de hachage (`id`) et une clé de tri (`name`), la clé ressemblera à ceci : ``` type User = { id: number name: string age: number isVerified: boolean friendsIds: string[] } const key: DynamoDBKey = { id: 1, name: 'XXXXXXXXXX', } ``` + `populateIndexFields?: boolean` (facultatif) Valeur booléenne qui, lorsqu'elle est activée en même temps que le`customPartitionKey`, crée de nouvelles entrées pour chaque enregistrement de la table de synchronisation delta, en particulier dans les colonnes `gsi_ds_pk` et`gsi_ds_sk`. **`Type ScanInput`** ``` ScanInput: { consistentRead?: boolean | null; filter?: DynamoDBFilterObject | null; index?: string | null; limit?: number | null; nextToken?: string | null; scanIndexForward?: boolean | null; segment?: number; select?: DynamoDBSelectAttributes; totalSegments?: number; } ``` **Déclaration de type** + `consistentRead?: boolean | null` (facultatif) Un booléen facultatif pour indiquer des lectures cohérentes lors de l'interrogation de DynamoDB. La valeur par défaut est `false`. + `filter?: DynamoDBFilterObject | null` (facultatif) Filtre facultatif à appliquer aux résultats après les avoir extraits du tableau. + `index?: string | null` (facultatif) Nom facultatif de l'index à analyser. + `limit?: number | null` (facultatif) Nombre maximal facultatif de résultats à renvoyer. + `nextToken?: string | null` (facultatif) Un jeton de pagination facultatif pour poursuivre une requête précédente. Il a été obtenu à partir d'une requête précédente. + `scanIndexForward?: boolean | null` (facultatif) Un booléen facultatif indiquant si la requête est exécutée par ordre croissant ou décroissant. Par défaut, cette valeur indique `true`. + `segment?: number` (facultatif) + `select?: DynamoDBSelectAttributes` (facultatif) Attributs à renvoyer depuis DynamoDB. Par défaut, le résolveur AWS AppSync DynamoDB renvoie uniquement les attributs projetés dans l'index. Les valeurs prises en charge sont : + `ALL_ATTRIBUTES` Renvoie tous les attributs d'élément de la table ou de l'index spécifié. Si vous interrogez un index secondaire local, DynamoDB extrait l'élément entier de la table parent pour chaque élément correspondant de l'index. Si l'index est configuré de façon à projeter tous les attributs de l'élément, toutes les données peuvent être obtenues à partir de l'index secondaire local, et aucune extraction n'est nécessaire. + `ALL_PROJECTED_ATTRIBUTES` Renvoie tous les attributs qui ont été projetés dans l'index. Si l'index est configuré de façon à projeter tous les attributs, la valeur renvoyée revient à spécifier `ALL_ATTRIBUTES`. + `SPECIFIC_ATTRIBUTES` Renvoie uniquement les attributs répertoriés dans`ProjectionExpression`. Cette valeur de retour revient à spécifier `ProjectionExpression` sans spécifier de valeur pour`AttributesToGet`. + `totalSegments?: number` (facultatif) **`Type DynamoDBSyncInput`** ``` DynamoDBSyncInput: { basePartitionKey?: string; deltaIndexName?: string; filter?: DynamoDBFilterObject | null; lastSync?: number; limit?: number | null; nextToken?: string | null; } ``` **Déclaration de type** + `basePartitionKey?: string` (facultatif) La clé de partition de la table de base à utiliser lors d'une opération de synchronisation. Ce champ permet d'effectuer une opération de synchronisation lorsque la table utilise une clé de partition personnalisée. + `deltaIndexName?: string` (facultatif) Index utilisé pour l'opération de synchronisation. Cet index est nécessaire pour activer une opération de synchronisation sur l'ensemble de la table delta store lorsque la table utilise une clé de partition personnalisée. L'opération de synchronisation sera effectuée sur le GSI (créé sur `gsi_ds_pk` et`gsi_ds_sk`). + `filter?: DynamoDBFilterObject | null` (facultatif) Filtre facultatif à appliquer aux résultats après les avoir extraits du tableau. + `lastSync?: number` (facultatif) Moment, en millisecondes, auquel la dernière opération de synchronisation réussie a commencé. Si spécifié, seuls les éléments qui ont changé après `lastSync` sont retournés. Ce champ ne doit être rempli qu'après avoir récupéré toutes les pages d'une opération de synchronisation initiale. En cas d'omission, les résultats de la table de base seront renvoyés. Dans le cas contraire, les résultats de la table delta seront renvoyés. + `limit?: number | null` (facultatif) Nombre maximal facultatif d'éléments à évaluer simultanément. Si cette option est omise, la limite par défaut sera définie sur `100` éléments. La valeur maximale de ce champ est `1000` éléments. + `nextToken?: string | null` (facultatif) **`Type DynamoDBUpdateInput`** ``` DynamoDBUpdateInput: { _version?: number; condition?: DynamoDBFilterObject; customPartitionKey?: string; key: DynamoDBKey; populateIndexFields?: boolean; update: DynamoDBUpdateObject; } ``` **Déclaration de type** + `_version?: number` (facultatif) + `condition?: DynamoDBFilterObject` (facultatif) Lorsque vous mettez à jour un objet dans DynamoDB, vous pouvez éventuellement spécifier une expression conditionnelle qui détermine si la demande doit aboutir ou non en fonction de l'état de l'objet déjà présent dans DynamoDB avant l'exécution de l'opération. + `customPartitionKey?: string` (facultatif) Lorsqu'elle est activée, la `customPartitionKey` valeur modifie le format des `ds_pk` enregistrements `ds_sk` et utilisés par la table de synchronisation delta lorsque le versionnement est activé. Lorsque cette option est activée, le traitement de l'`populateIndexFields`entrée est également activé. + `key: DynamoDBKey` (obligatoire) Paramètre obligatoire qui spécifie la clé de l'élément en cours de mise à jour dans DynamoDB. Les éléments DynamoDB peuvent avoir une seule clé de hachage ou des clés de hachage et de tri. + `populateIndexFields?: boolean` (facultatif) Valeur booléenne qui, lorsqu'elle est activée en même temps que le`customPartitionKey`, crée de nouvelles entrées pour chaque enregistrement de la table de synchronisation delta, en particulier dans les colonnes `gsi_ds_pk` et`gsi_ds_sk`. + `update: DynamoDBUpdateObject` Objet qui spécifie les attributs à mettre à jour ainsi que leurs nouvelles valeurs. L'objet de mise à jour peut être utilisé avec `add` `remove``replace`,`increment`,,`decrement`,`append`,`prepend`,`updateListItem`. ## Fonctions du module Amazon RDS Les fonctions du module Amazon RDS offrent une expérience améliorée lors de l'interaction avec les bases de données configurées avec l'API Amazon RDS Data. Le module est importé à l'aide de `@aws-appsync/utils/rds` : ``` import * as rds from '@aws-appsync/utils/rds'; ``` Les fonctions peuvent également être importées individuellement. Par exemple, l'importation ci-dessous utilise `sql` : ``` import { sql } from '@aws-appsync/utils/rds'; ``` ### Fonctions Vous pouvez utiliser les aides utilitaires du module AWS AppSync RDS pour interagir avec votre base de données. #### Select L'`select`utilitaire crée une `SELECT` instruction pour interroger votre base de données relationnelle. **Usage de base** Dans sa forme de base, vous pouvez spécifier la table que vous souhaitez interroger : ``` import { select, createPgStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { // Generates statement: // "SELECT * FROM "persons" return createPgStatement(select({table: 'persons'})); } ``` Notez que vous pouvez également spécifier le schéma dans l'identifiant de votre table : ``` import { select, createPgStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { // Generates statement: // SELECT * FROM "private"."persons" return createPgStatement(select({table: 'private.persons'})); } ``` **Spécification des colonnes** Vous pouvez définir des colonnes à l'aide de `columns` cette propriété. S'il n'est pas défini sur une valeur, la valeur par défaut est : `*` ``` export function request(ctx) { // Generates statement: // SELECT "id", "name" // FROM "persons" return createPgStatement(select({ table: 'persons', columns: ['id', 'name'] })); } ``` Vous pouvez également spécifier le tableau d'une colonne : ``` export function request(ctx) { // Generates statement: // SELECT "id", "persons"."name" // FROM "persons" return createPgStatement(select({ table: 'persons', columns: ['id', 'persons.name'] })); } ``` **Limites et compensations** Vous pouvez appliquer `limit` et répondre `offset` à la requête : ``` export function request(ctx) { // Generates statement: // SELECT "id", "name" // FROM "persons" // LIMIT :limit // OFFSET :offset return createPgStatement(select({ table: 'persons', columns: ['id', 'name'], limit: 10, offset: 40 })); } ``` **Commander par** Vous pouvez trier vos résultats à l'aide de `orderBy` cette propriété. Fournissez un tableau d'objets spécifiant la colonne et une `dir` propriété facultative : ``` export function request(ctx) { // Generates statement: // SELECT "id", "name" FROM "persons" // ORDER BY "name", "id" DESC return createPgStatement(select({ table: 'persons', columns: ['id', 'name'], orderBy: [{column: 'name'}, {column: 'id', dir: 'DESC'}] })); } ``` **Filtres** Vous pouvez créer des filtres à l'aide de l'objet de condition spéciale : ``` export function request(ctx) { // Generates statement: // SELECT "id", "name" // FROM "persons" // WHERE "name" = :NAME return createPgStatement(select({ table: 'persons', columns: ['id', 'name'], where: {name: {eq: 'Stephane'}} })); } ``` Vous pouvez également combiner des filtres : ``` export function request(ctx) { // Generates statement: // SELECT "id", "name" // FROM "persons" // WHERE "name" = :NAME and "id" > :ID return createPgStatement(select({ table: 'persons', columns: ['id', 'name'], where: {name: {eq: 'Stephane'}, id: {gt: 10}} })); } ``` Vous pouvez également créer des `OR` déclarations : ``` export function request(ctx) { // Generates statement: // SELECT "id", "name" // FROM "persons" // WHERE "name" = :NAME OR "id" > :ID return createPgStatement(select({ table: 'persons', columns: ['id', 'name'], where: { or: [ { name: { eq: 'Stephane'} }, { id: { gt: 10 } } ]} })); } ``` Vous pouvez également annuler une condition avec `not` : ``` export function request(ctx) { // Generates statement: // SELECT "id", "name" // FROM "persons" // WHERE NOT ("name" = :NAME AND "id" > :ID) return createPgStatement(select({ table: 'persons', columns: ['id', 'name'], where: { not: [ { name: { eq: 'Stephane'} }, { id: { gt: 10 } } ]} })); } ``` Vous pouvez également utiliser les opérateurs suivants pour comparer des valeurs : | | | Opérateur | Description | Types de valeurs possibles | | --- |--- |--- | | eq | Égal à | nombre, chaîne, booléen | | ne | Non égal à | nombre, chaîne, booléen | | le | Inférieur ou égal à | nombre, chaîne | | lt | Inférieur à | nombre, chaîne | | gm | Supérieur ou égal à | nombre, chaîne | | gt | Supérieur à | nombre, chaîne | | contient | Comme | chaîne | | NE CONTIENT PAS | Pas comme | chaîne | | Commence par | Commence par le préfixe | chaîne | | between | Entre deux valeurs | nombre, chaîne | | L'attribut existe | L'attribut n'est pas nul | nombre, chaîne, booléen | | size | vérifie la longueur de l'élément | chaîne | #### Insert L'`insert`utilitaire fournit un moyen simple d'insérer des éléments d'une seule ligne dans votre base de données avec l'`INSERT`opération. **Insertions d'un seul article** Pour insérer un élément, spécifiez le tableau, puis transmettez votre objet de valeurs. Les clés d'objet sont mappées aux colonnes de votre tableau. Les noms des colonnes sont automatiquement ignorés et les valeurs sont envoyées à la base de données à l'aide de la variable map : ``` import { insert, createMySQLStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { const { input: values } = ctx.args; const insertStatement = insert({ table: 'persons', values }); // Generates statement: // INSERT INTO `persons`(`name`) // VALUES(:NAME) return createMySQLStatement(insertStatement) } ``` **Cas d'utilisation de MySQL** Vous pouvez combiner un `insert` suivi d'un `select` pour récupérer la ligne que vous avez insérée : ``` import { insert, select, createMySQLStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { const { input: values } = ctx.args; const insertStatement = insert({ table: 'persons', values }); const selectStatement = select({ table: 'persons', columns: '*', where: { id: { eq: values.id } }, limit: 1, }); // Generates statement: // INSERT INTO `persons`(`name`) // VALUES(:NAME) // and // SELECT * // FROM `persons` // WHERE `id` = :ID return createMySQLStatement(insertStatement, selectStatement) } ``` **Cas d'utilisation de Postgres** Avec Postgres, vous pouvez l'utiliser [https://www.postgresql.org/docs/current/dml-returning.html](https://www.postgresql.org/docs/current/dml-returning.html)pour obtenir des données à partir de la ligne que vous avez insérée. Il accepte `*` un tableau de noms de colonnes : ``` import { insert, createPgStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { const { input: values } = ctx.args; const insertStatement = insert({ table: 'persons', values, returning: '*' }); // Generates statement: // INSERT INTO "persons"("name") // VALUES(:NAME) // RETURNING * return createPgStatement(insertStatement) } ``` #### Mettre à jour L'`update`utilitaire vous permet de mettre à jour les lignes existantes. Vous pouvez utiliser l'objet condition pour appliquer des modifications aux colonnes spécifiées dans toutes les lignes qui répondent à la condition. Supposons, par exemple, que nous ayons un schéma qui nous permet de réaliser cette mutation. Nous voulons mettre à jour les `name` de `Person` avec la `id` valeur de`3`, mais uniquement si nous les connaissons (`known_since`) depuis l'année `2000` : ``` mutation Update { updatePerson( input: {id: 3, name: "Jon"}, condition: {known_since: {ge: "2000"}} ) { id name } } ``` Notre résolveur de mises à jour ressemble à ceci : ``` import { update, createPgStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { const { input: { id, ...values }, condition } = ctx.args; const where = { ...condition, id: { eq: id }, }; const updateStatement = update({ table: 'persons', values, where, returning: ['id', 'name'], }); // Generates statement: // UPDATE "persons" // SET "name" = :NAME, "birthday" = :BDAY, "country" = :COUNTRY // WHERE "id" = :ID // RETURNING "id", "name" return createPgStatement(updateStatement) } ``` Nous pouvons ajouter une vérification à notre condition pour nous assurer que seule la ligne dont la clé primaire est `id` égale à `3` est mise à jour. De même, pour Postgres`inserts`, vous pouvez utiliser `returning` pour renvoyer les données modifiées. #### Supprimer L'`remove`utilitaire vous permet de supprimer des lignes existantes. Vous pouvez utiliser l'objet de condition sur toutes les lignes qui répondent à la condition. Notez qu'il `delete` s'agit d'un mot clé réservé dans JavaScript. `remove`doit être utilisé à la place : ``` import { remove, createPgStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { const { input: { id }, condition } = ctx.args; const where = { ...condition, id: { eq: id } }; const deleteStatement = remove({ table: 'persons', where, returning: ['id', 'name'], }); // Generates statement: // DELETE "persons" // WHERE "id" = :ID // RETURNING "id", "name" return createPgStatement(updateStatement) } ``` ### Forçage de type Dans certains cas, vous souhaiterez peut-être plus de précisions quant au type d'objet correct à utiliser dans votre déclaration. Vous pouvez utiliser les indications de type fournies pour spécifier le type de vos paramètres. AWS AppSync prend en charge les [mêmes indications de type](https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_SqlParameter.html#rdsdtataservice-Type-SqlParameter-typeHint) que l'API Data. Vous pouvez convertir vos paramètres en utilisant les `typeHint` fonctions du AWS AppSync `rds` module. L'exemple suivant vous permet d'envoyer un tableau sous forme de valeur qui est convertie en objet JSON. Nous utilisons l'`->`opérateur pour récupérer l'élément situé `index` `2` dans le tableau JSON : ``` import { sql, createPgStatement, toJsonObject, typeHint } from '@aws-appsync/utils/rds'; export function request(ctx) { const arr = ctx.args.list_of_ids const statement = sql`select ${typeHint.JSON(arr)}->2 as value` return createPgStatement(statement) } export function response(ctx) { return toJsonObject(ctx.result)[0][0].value } ``` Le casting est également utile lors de la manipulation et de `DATE` la comparaison`TIME`, et `TIMESTAMP` : ``` import { select, createPgStatement, typeHint } from '@aws-appsync/utils/rds'; export function request(ctx) { const when = ctx.args.when const statement = select({ table: 'persons', where: { createdAt : { gt: typeHint.DATETIME(when) } } }) return createPgStatement(statement) } ``` Voici un autre exemple montrant comment envoyer la date et l'heure actuelles : ``` import { sql, createPgStatement, typeHint } from '@aws-appsync/utils/rds'; export function request(ctx) { const now = util.time.nowFormatted('YYYY-MM-dd HH:mm:ss') return createPgStatement(sql`select ${typeHint.TIMESTAMP(now)}`) } ``` **Indications de type disponibles** + `typeHint.DATE`- Le paramètre correspondant est envoyé sous forme d'objet de `DATE` ce type à la base de données. Le format accepté est `YYYY-MM-DD`. + `typeHint.DECIMAL`- Le paramètre correspondant est envoyé sous forme d'objet de `DECIMAL` ce type à la base de données. + `typeHint.JSON`- Le paramètre correspondant est envoyé sous forme d'objet de `JSON` ce type à la base de données. + `typeHint.TIME`- La valeur de paramètre de chaîne correspondante est envoyée sous forme d'objet de `TIME` ce type à la base de données. Le format accepté est `HH:MM:SS[.FFF]`. + `typeHint.TIMESTAMP`- La valeur de paramètre de chaîne correspondante est envoyée sous forme d'objet de `TIMESTAMP` ce type à la base de données. Le format accepté est `YYYY-MM-DD HH:MM:SS[.FFF]`. + `typeHint.UUID`- La valeur de paramètre de chaîne correspondante est envoyée sous forme d'objet de `UUID` ce type à la base de données.