Fonctions du module DynamoDB Fonctions RDS du module Amazon

Modules intégrés

Les modules font partie de l'APPSYNC_JSenvironnement d'exécution et fournissent des utilitaires pour aider à écrire des JavaScript résolveurs et des fonctions.

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

get<T>(payload: GetInput): DynamoDBGetItemRequest

Astuce

Voir Inputs pour plus d'informations sur GetInput.

Génère un DynamoDBGetItemRequest objet pour envoyer une GetItemrequête à DynamoDB.


import { get } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	return get({ key: { id: ctx.args.id } });
}

put<T>(payload): DynamoDBPutItemRequest

Génère un DynamoDBPutItemRequest objet pour envoyer une PutItemrequê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<T>(payload): DynamoDBDeleteItemRequest

Génère un DynamoDBDeleteItemRequest objet pour envoyer une DeleteItemrequête à DynamoDB.


import * as ddb from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	return ddb.remove({ key: { id: ctx.args.id } });
}

scan<T>(payload): DynamoDBScanRequest

Génère un DynamoDBScanRequest pour envoyer une demande de 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<T>(payload): DynamoDBSyncRequest

Génère un DynamoDBSyncRequest objet pour effectuer une demande de synchronisation. 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<T>(payload): DynamoDBUpdateItemRequest

Génère un DynamoDBUpdateItemRequest objet pour envoyer une UpdateItemrequê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';

add<T>(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 <T>(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 <T>(payload)

Fonction d'assistance qui s'ajoute à 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.prepend(newFriendIds),
	};
	return update({ key: { id: 1 }, update: updateObj });
}

replace <T>(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 <T>(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

Type GetInput<T>


GetInput<T>: { 
    consistentRead?: boolean; 
    key: DynamoDBKey<T>; 
}

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<T> (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<T>


PutInput<T>: { 
    _version?: number; 
    condition?: DynamoDBFilterObject<T> | null; 
    customPartitionKey?: string; 
    item: Partial<T>; 
    key: DynamoDBKey<T>; 
    populateIndexFields?: boolean; 
}

Déclaration de type

_version?: number (facultatif)
condition?: DynamoDBFilterObject<T> | 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'populateIndexFieldsentrée est également activé.
item: Partial<T> (obligatoire)

Le reste des attributs de l'élément à placer dans DynamoDB.
key: DynamoDBKey<T> (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 lecustomPartitionKey, crée de nouvelles entrées pour chaque enregistrement de la table de synchronisation delta, en particulier dans les colonnes gsi_ds_pk etgsi_ds_sk. Pour plus d'informations, consultez la section Détection et synchronisation des conflits dans le manuel du AWS AppSync développeur.

Type QueryInput<T>


QueryInput<T>: ScanInput<T> & { 
    query: DynamoDBKeyCondition<Required<T>>; 
}

Déclaration de type

query: DynamoDBKeyCondition<Required<T>> (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 : idname, et age :
```
const query: QueryInput<User> = {
    name: { eq: 'John' },
    age: { gt: 20 },
}
```

Type RemoveInput<T>


RemoveInput<T>: { 
    _version?: number; 
    condition?: DynamoDBFilterObject<T>; 
    customPartitionKey?: string; 
    key: DynamoDBKey<T>; 
    populateIndexFields?: boolean; 
}

Déclaration de type

_version?: number (facultatif)
condition?: DynamoDBFilterObject<T> (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<Task> = {
  owner: { eq: 'XXXXXXXXXXXXXXXX' },
}

remove<Task>({
   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'populateIndexFieldsentrée est également activé.
key: DynamoDBKey<T> (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 utilisateurid, la clé ressemblera à ceci :
```
type User = {
	id: number
	name: string
	age: number
	isVerified: boolean
}
const key: DynamoDBKey<User> = {
	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<User> = {
	id: 1,
	name: 'XXXXXXXXXX',
}   
```
populateIndexFields?: boolean (facultatif)

Valeur booléenne qui, lorsqu'elle est activée en même temps que lecustomPartitionKey, crée de nouvelles entrées pour chaque enregistrement de la table de synchronisation delta, en particulier dans les colonnes gsi_ds_pk etgsi_ds_sk.

Type ScanInput<T>


ScanInput<T>: { 
    consistentRead?: boolean | null; 
    filter?: DynamoDBFilterObject<T> | 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<T> | 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 dansProjectionExpression. Cette valeur de retour revient à spécifier ProjectionExpression sans spécifier de valeur pourAttributesToGet.
totalSegments?: number (facultatif)

Type DynamoDBSyncInput<T>


DynamoDBSyncInput<T>: { 
    basePartitionKey?: string; 
    deltaIndexName?: string; 
    filter?: DynamoDBFilterObject<T> | 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 etgsi_ds_sk).
filter?: DynamoDBFilterObject<T> | 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<T>


DynamoDBUpdateInput<T>: { 
    _version?: number; 
    condition?: DynamoDBFilterObject<T>; 
    customPartitionKey?: string; 
    key: DynamoDBKey<T>; 
    populateIndexFields?: boolean; 
    update: DynamoDBUpdateObject<T>; 
}

Déclaration de type

_version?: number (facultatif)
condition?: DynamoDBFilterObject<T> (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'populateIndexFieldsentrée est également activé.
key: DynamoDBKey<T> (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 lecustomPartitionKey, crée de nouvelles entrées pour chaque enregistrement de la table de synchronisation delta, en particulier dans les colonnes gsi_ds_pk etgsi_ds_sk.
update: DynamoDBUpdateObject<T>

Objet qui spécifie les attributs à mettre à jour ainsi que leurs nouvelles valeurs. L'objet de mise à jour peut être utilisé avec add removereplace,increment,,decrement,append,prepend,updateListItem.

Fonctions RDS du module Amazon

Les fonctions RDS du module Amazon offrent une expérience améliorée lors de l'interaction avec des bases de données configurées avec Amazon RDS DataAPI. 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 utilitaires du AWS AppSync RDS module pour interagir avec votre base de données.

L'selectutilitaire crée une SELECT instruction pour interroger votre base de données relationnelle.

Utilisation 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é. Si aucune valeur n'est définie, 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érieure à	nombre, chaîne
contient	Comme	chaîne
notContains	Pas comme	chaîne
beginsWith	Commence par le préfixe	chaîne
between	Entre deux valeurs	nombre, chaîne
attributeExists	L'attribut n'est pas nul	nombre, chaîne, booléen
size	vérifie la longueur de l'élément	chaîne

L'insertutilitaire fournit un moyen simple d'insérer des éléments d'une seule ligne dans votre base de données avec l'INSERTopé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)
}

Mon cas SQL d'utilisation

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 returningpour 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)
}

L'updateutilitaire 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 de3, 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 Postgresinserts, vous pouvez utiliser returning pour renvoyer les données modifiées.

L'removeutilitaire 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. removedoit ê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 que les donnéesAPI. 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 JSON objet. Nous utilisons l'->opérateur pour récupérer l'élément situé index 2 dans le JSON tableau :


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 comparaisonTIME, 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.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Utilitaires intégrés

utilitaires d'exécution