Expresiones de condición

Al mutar objetos en DynamoDB utilizando las operaciones de DynamoDB PutItem, UpdateItem y DeleteItem, puede especificar opcionalmente una expresión de condición que determine si la solicitud se debe atender o no en función del estado del objeto que ya está en DynamoDB antes de ejecutar la operación.

La función de DynamoDB de AWS AppSync permite especificar una expresión de condición en los objetos de solicitud PutItem, UpdateItem y DeleteItem, así como la estrategia que debe seguirse en caso de que la condición no se cumpla y el objeto no se actualice.

Ejemplo 1

El siguiente objeto de solicitud PutItem no tiene una expresión de condición. Como resultado, pone un elemento en DynamoDB incluso si ya existe un elemento con la misma clave, lo que permite sobrescribir el elemento existente.

import { util } from '@aws-appsync/utils';
export function request(ctx) {
  const { foo, bar, ...values} = ctx.args
  return {
    operation: 'PutItem',
    key: util.dynamodb.toMapValues({foo, bar}),
    attributeValues: util.dynamodb.toMapValues(values),
  };
}

Ejemplo 2

El siguiente objeto PutItem tiene una expresión de condición que permitirá que la operación se complete solo si no existe un elemento con la misma clave en DynamoDB.

import { util } from '@aws-appsync/utils';
export function request(ctx) {
  const { foo, bar, ...values} = ctx.args
  return {
    operation: 'PutItem',
    key: util.dynamodb.toMapValues({foo, bar}),
    attributeValues: util.dynamodb.toMapValues(values),
    condition: { expression: "attribute_not_exists(id)" }
  };
}

De forma predeterminada, si se produce un error en la comprobación de condición, la función de DynamoDB de AWS AppSync proporciona un error para la mutación.

Sin embargo, la función de DynamoDB de AWS AppSync ofrece algunas características adicionales para ayudar a los desarrolladores a gestionar algunos casos de periferia habituales:

Estos casos se describen con más detalle en la sección de gestión de un error de comprobación de la condición.

Para obtener más información sobre las expresiones de condiciones de DynamoDB, consulte la documentación de expresiones de condición de DynamoDB.

Especificación de una condición

Todos los objetos de solicitud PutItem, UpdateItem y DeleteItem permiten especificar una sección condition opcional. Si se omite, no se comprobará ninguna condición. Si se especifica, la condición debe ser true para que la operación se lleve a cabo correctamente.

Las secciones condition tienen la siguiente estructura:

type ConditionCheckExpression = {
  expression: string;
  expressionNames?: { [key: string]: string};
  expressionValues?: { [key: string]: any};
  equalsIgnore?: string[];
  consistentRead?: boolean;
  conditionalCheckFailedHandler?: {
    strategy: 'Custom' | 'Reject';
    lambdaArn?: string;
  };
};

Los campos siguientes especifican la condición:

El resto de los campos indican a la función de DynamoDB de AWS AppSync cómo gestionar los casos en que no se cumpla la condición:

Gestión de un error de comprobación de la condición

Cuando la condición no se cumple, la función de DynamoDB de AWS AppSync puede transferir el error para la mutación y el valor actual del objeto mediante la utilidad util.appendError. Sin embargo, la función de DynamoDB de AWS AppSync ofrece algunas características adicionales para ayudar a los desarrolladores a gestionar algunos casos de periferia habituales:

El diagrama de flujo de este proceso es:

Comprobación del resultado deseado

Cuando la condición no se cumple, la función de DynamoDB de AWS AppSync realiza una solicitud de DynamoDB GetItem para obtener el valor actual del elemento de DynamoDB. De forma predeterminada, utiliza una lectura altamente coherente; sin embargo, esto puede configurarse mediante el campo consistentRead en el bloque condition y compararlo con el resultado esperado:

Si el estado actual del objeto en DynamoDB es diferente del resultado esperado, la función de DynamoDB de AWS AppSync sigue la estrategia configurada para rechazar la mutación o invocar una función de Lambda para determinar qué hacer a continuación.

Aplicación de la estrategia de rechazo

Al seguir la estrategia Reject, la función de DynamoDB de AWS AppSync devuelve un error para la mutación.

Por ejemplo, si se recibe la solicitud de mutación siguiente:

mutation {
    updatePerson(id: 1, name: "Steve", expectedVersion: 1) {
        Name
        theVersion
    }
}

Si el elemento devuelto de DynamoDB tiene un aspecto similar al siguiente:

{
   "id" : { "S" : "1" },
   "name" : { "S" : "Steve" },
   "version" : { "N" : 8 }
}

Y el controlador de respuestas de función tiene el siguiente aspecto:

import { util } from '@aws-appsync/utils';
export function response(ctx) {
  const { version, ...values } = ctx.result;
  const result = { ...values, theVersion: version };
  if (ctx.error) {
    if (error) {
      return util.appendError(error.message, error.type, result, null);
    }
  }
  return result
}

La respuesta GraphQL tiene este aspecto:

{
  "data": null,
  "errors": [
    {
      "message": "The conditional request failed (Service: AmazonDynamoDBv2; Status Code: 400; Error Code: ConditionalCheckFailedException; Request ID: ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ)"
      "errorType": "DynamoDB:ConditionalCheckFailedException",
      ...
    }
  ]
}

Además, si hay algún campo en el objeto devuelto que hayan cumplimentado otros solucionadores y si la mutación se ha efectuado satisfactoriamente, el objeto no se resuelve cuando se devuelve en la sección error.

Aplicación de la estrategia personalizada

Si se sigue la estrategia Custom, la función de DynamoDB de AWS AppSync invoca una función de Lambda para decidir qué hacer a continuación. La función Lambda selecciona una de las siguientes opciones:

La solicitud de invocación Lambda

La función de DynamoDB de AWS AppSync invoca la función de Lambda especificada en el lambdaArn. Se utiliza el mismo service-role-arn configurado en el origen de datos. La carga de la invocación tiene la siguiente estructura:

{
    "arguments": { ... },
    "requestMapping": {... },
    "currentValue": { ... },
    "resolver": { ... },
    "identity": { ... }
}

Los campos se definen de la siguiente manera:

Un ejemplo completo de la carga:

{
    "arguments": {
        "id": "1",
        "name": "Steve",
        "expectedVersion": 1
    },
    "requestMapping": {
        "version" : "2017-02-28",
        "operation" : "PutItem",
        "key" : {
           "id" : { "S" : "1" }
        },
        "attributeValues" : {
           "name" : { "S" : "Steve" },
           "version" : { "N" : 2 }
        },
        "condition" : {
           "expression" : "version = :expectedVersion",
           "expressionValues" : {
               ":expectedVersion" : { "N" : 1 }
           },
           "equalsIgnore": [ "version" ]
        }
    },
    "currentValue": {
        "id" : { "S" : "1" },
        "name" : { "S" : "Steve" },
        "version" : { "N" : 8 }
    },
    "resolver": {
        "tableName": "People",
        "awsRegion": "us-west-2",
        "parentType": "Mutation",
        "field": "updatePerson",
        "outputType": "Person"
    },
    "identity": {
        "accountId": "123456789012",
        "sourceIp": "x.x.x.x",
        "user": "AIDAAAAAAAAAAAAAAAAAA",
        "userArn": "arn:aws:iam::123456789012:user/appsync"
    }
}

La respuesta de invocación Lambda

La función de Lambda puede inspeccionar la carga de invocación y aplicar cualquier lógica de negocio para decidir la forma en que la función de DynamoDB de AWS AppSync debe gestionar el error. Existen tres opciones para gestionar el error de comprobación de condición:

A continuación se muestra un ejemplo de función Lambda para tratar una solicitud PutItem sin éxito. La lógica de negocio examina quién realizó la llamada. Si la realizó jeffTheAdmin, vuelve a intentar realizar la solicitud, actualizando version y expectedVersion desde el elemento actualmente en DynamoDB. De lo contrario, rechaza la mutación.

exports.handler = (event, context, callback) => {
    console.log("Event: "+ JSON.stringify(event));

    // Business logic goes here.

    var response;
    if ( event.identity.user == "jeffTheAdmin" ) {
        response = {
            "action" : "retry",
            "retryMapping" : {
                "attributeValues" : event.requestMapping.attributeValues,
                "condition" : {
                    "expression" : event.requestMapping.condition.expression,
                    "expressionValues" : event.requestMapping.condition.expressionValues
                }
            }
        }
        response.retryMapping.attributeValues.version = { "N" : event.currentValue.version.N + 1 }
        response.retryMapping.condition.expressionValues[':expectedVersion'] = event.currentValue.version

    } else {
        response = { "action" : "reject" }
    }

    console.log("Response: "+ JSON.stringify(response))
    callback(null, response)
};