Fonctions du module DynamoDB Fonctions du module Amazon RDS

Built-in modules

Les modules font partie de l'APPSYNC_JSenvironnement d'exécution et fournissent des utilitaires pour faciliter l'écriture de JavaScript résolveurs et de fonctions. Pour des exemples et des exemples, consultez le référentiel https://github.com/aws-samples/aws-appsync-resolver-samples GitHub aws-appsync-resolver-samples.

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 GetItem requê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 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<T>(payload): DynamoDBDeleteItemRequest

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

Génère un DynamoDBScanRequest pour envoyer une demande de numérisation à 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 reçoit uniquement 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 UpdateItem requête à DynamoDB.

Opérations

Les aides aux opérations vous permettent de prendre des mesures 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 les identifiants d'amis récemment ajoutés (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.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 de 10 le compteur d'un ami (friendsCount) :


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 ajoute un ajout à la liste existante dans DynamoDB.

Exemple

Pour ajouter les identifiants d'amis récemment ajoutés (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 <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 update (newFriendIds), cet exemple a permis de mettre updateListItem à jour les valeurs d'ID du deuxième élément (index :1, nouvel ID :102) et du troisième élément (index :2, nouvel ID :112) d'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)

Une valeur booléenne facultative permettant de spécifier si vous souhaitez effectuer une lecture parfaitement 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 delta sync lorsque la gestion des versions a été activée. Lorsque cette option est activée, le traitement de la populateIndexFields saisie est également activé.
item: Partial<T> (obligatoire)

Les autres attributs de l'élément à placer dans DynamoDB.
key: DynamoDBKey<T> (obligatoire)

Paramètre obligatoire qui spécifie la clé de l'élément de DynamoDB sur lequel la mise sera effectuée. Les éléments DynamoDB peuvent avoir une seule clé de hachage ou des clés de hachage et de tri.
populateIndexFields?: boolean (facultatif)

Une valeur booléenne qui, lorsqu'elle est activée avec 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 des conflits et synchronisation dans le Guide 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 pour une clé de partition doit être une égalité et la clé de tri une comparaison ou un beginsWith (s'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 à l'origine de 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 contrôle de version est activé. Lorsque cette option est activée, le traitement de la populateIndexFields saisie est également activé.
key: DynamoDBKey<T> (obligatoire)

Paramètre obligatoire qui spécifie la clé de l'élément de DynamoDB à supprimer. Les éléments DynamoDB peuvent avoir une seule clé de hachage ou des clés de hachage et de tri.

Exemple

Si a User ne possède que 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)

Une valeur booléenne qui, lorsqu'elle est activée avec 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 optionnel à appliquer aux résultats après les avoir récupérés dans le tableau.
index?: string | null (facultatif)

Nom facultatif de l'index à scanner.
limit?: number | null (facultatif)

Un nombre maximum 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 pour indiquer si la requête est exécutée dans l'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 des éléments de la table ou de l'index spécifié. Si vous interrogez un index secondaire local, DynamoDB extrait l'intégralité de l'élément 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 requis pour activer une opération de synchronisation sur l'ensemble de la table Delta Store lorsque celle-ci 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 optionnel à appliquer aux résultats après les avoir récupérés dans le tableau.
lastSync?: number (facultatif)

Moment, en millisecondes d'époque, 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 renseigné 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)

Un nombre maximum facultatif d'éléments à évaluer en une seule fois. 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 contrôle de version est activé. Lorsque cette option est activée, le traitement de la populateIndexFields saisie est également activé.
key: DynamoDBKey<T> (obligatoire)

Paramètre obligatoire qui spécifie la clé de l'élément de DynamoDB en cours de mise à jour. Les éléments DynamoDB peuvent avoir une seule clé de hachage ou des clés de hachage et de tri.
populateIndexFields?: boolean (facultatif)

Une valeur booléenne qui, lorsqu'elle est activée avec 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 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 utilitaires du module AWS AppSync RDS 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 spécifier des colonnes à l'aide de columns cette propriété. Si aucune valeur n'est définie, la valeur par défaut est la suivante : *


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 décalages

Vous pouvez postuler 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 avec la orderBy 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 relevés :


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 les valeurs :

Opérateur	Description	Types de valeurs possibles
eq	Égal à	nombre, chaîne de caractères, booléen
ne	Non égal à	nombre, chaîne, booléen
le	Inférieur ou égal à	numéro, chaîne
lt	Inférieur à	numéro, chaîne
gm	Supérieur ou égal à	numéro, chaîne
gt	Supérieur à	numéro, chaîne
contient	Comme	chaîne
Ne contient pas	Pas comme	chaîne
Commence par	Commence par un préfixe	chaîne
between	Entre deux valeurs	numéro, 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

L'insertutilitaire fournit un moyen simple d'insérer des éléments d'une seule ligne dans votre base de données à l'aide de cette INSERT opération.

Insertions d'articles uniques

Pour insérer un élément, spécifiez le tableau, puis transmettez votre objet de valeurs. Les clés des objets sont mappées aux colonnes de votre tableau. Les noms de colonnes sont automatiquement échappé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 utiliser returning pour obtenir des données à partir de la ligne que vous avez insérée. Il accepte * ou 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 de condition pour appliquer des modifications aux colonnes spécifiées dans toutes les lignes qui satisfont à la condition. Par exemple, supposons que nous ayons un schéma qui nous permet d'effectuer cette mutation. Nous voulons mettre à jour le name of 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 satisfont à 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 être plus précis quant au type d'objet correct à utiliser dans votre instruction. Vous pouvez utiliser les conseils de type fournis pour spécifier le type de vos paramètres. AWS AppSync prend en charge les mêmes indicateurs de type que l'API Data. Vous pouvez convertir vos paramètres à l'aide typeHint des fonctions du AWS AppSync rds module.

L'exemple suivant vous permet d'envoyer un tableau sous la forme d'une valeur 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 pour manipuler et comparer DATETIME, 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é en tant qu'objet du DATE type à la base de données. Le format accepté est YYYY-MM-DD.
typeHint.DECIMAL- Le paramètre correspondant est envoyé en tant qu'objet du DECIMAL type à la base de données.
typeHint.JSON- Le paramètre correspondant est envoyé en tant qu'objet du JSON type à la base de données.
typeHint.TIME- La valeur de paramètre de chaîne correspondante est envoyée en tant qu'objet du TIME 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 en tant qu'objet du TIMESTAMP 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 en tant qu'objet du UUID 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

Built-in services publics

utilitaires d'exécution