Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Ekspresi kondisi

Saat Anda mengubah objek di DynamoDB dengan menggunakan operasiPutItem,UpdateItem, dan DeleteItem DynamoDB, Anda dapat secara opsional menentukan ekspresi kondisi yang mengontrol apakah permintaan harus berhasil atau tidak, berdasarkan status objek yang sudah ada di DynamoDB sebelum operasi dilakukan.

Fungsi AWS AppSync DynamoDB memungkinkan ekspresi kondisi untuk ditentukan dalamPutItem,UpdateItem, dan objek DeleteItem permintaan, dan juga strategi untuk diikuti jika kondisi gagal dan objek tidak diperbarui.

Contoh 1

Objek PutItem permintaan berikut tidak memiliki ekspresi kondisi. Akibatnya, ia menempatkan item di DynamoDB bahkan jika item dengan kunci yang sama sudah ada, sehingga mengganti item yang ada.

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),
  };
}

Contoh 2

Ob PutItem jek berikut memang memiliki ekspresi kondisi yang memungkinkan operasi berhasil hanya jika item dengan kunci yang sama tidak ada di 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)" }
  };
}

Secara default, jika pemeriksaan kondisi gagal, fungsi AWS AppSync DynamoDB memberikan kesalahan untuk mutasi.

Namun, fungsi AWS AppSync DynamoDB menawarkan beberapa fitur tambahan untuk membantu pengembang menangani beberapa kasus tepi umum:

Ini dijelaskan secara lebih rinci di bagian Menangani kegagalan pemeriksaan kondisi.

Untuk informasi selengkapnya tentang ekspresi kondisi DynamoDB, lihat dokumentasi Dynam ConditionExpressions oDB.

Menentukan kondisi

Ob PutItem jekUpdateItem,, dan DeleteItem permintaan semuanya memungkinkan condition bagian opsional untuk ditentukan. Jika dihilangkan, tidak ada pemeriksaan kondisi yang dilakukan. Jika ditentukan, kondisi harus benar agar operasi berhasil.

Sebuah condition bagian memiliki struktur sebagai berikut:

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

Bidang berikut menentukan kondisi:

Bidang yang tersisa memberi tahu fungsi AWS AppSync DynamoDB cara menangani kegagalan pemeriksaan kondisi:

Menangani kegagalan pemeriksaan kondisi

Ketika pemeriksaan kondisi gagal, fungsi AWS AppSync DynamoDB dapat meneruskan kesalahan untuk mutasi dan nilai objek saat ini dengan menggunakan utilitasutil.appendError. Namun, fungsi AWS AppSync DynamoDB menawarkan beberapa fitur tambahan untuk membantu pengembang menangani beberapa kasus tepi umum:

Diagram alur untuk proses ini adalah:

Memeriksa hasil yang diinginkan

Ketika pemeriksaan kondisi gagal, fungsi AWS AppSync DynamoDB melakukan permintaan GetItem DynamoDB untuk mendapatkan nilai item saat ini dari DynamoDB. Secara default, ini menggunakan pembacaan yang sangat konsisten, namun ini dapat dikonfigurasi menggunakan consistentRead bidang di condition blok dan membandingkannya dengan hasil yang diharapkan:

Jika status objek saat ini di DynamoDB berbeda dari hasil yang diharapkan, fungsi AWS AppSync DynamoDB mengikuti strategi yang dikonfigurasi, untuk menolak mutasi atau memanggil fungsi Lambda untuk menentukan apa yang harus dilakukan selanjutnya.

Mengikuti strategi “tolak”

Saat mengikuti Reject strategi, fungsi AWS AppSync DynamoDB mengembalikan kesalahan untuk mutasi.

Misalnya, diberikan permintaan mutasi berikut:

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

Jika item yang dikembalikan dari DynamoDB terlihat seperti berikut:

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

Dan pengendali respons fungsi terlihat seperti berikut:

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
}

Respons GraphQL terlihat seperti berikut:

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

Juga, jika ada bidang dalam objek yang dikembalikan diisi oleh resolver lain dan mutasi telah berhasil, mereka tidak akan diselesaikan ketika objek dikembalikan di error bagian tersebut.

Mengikuti strategi “kustom”

Saat mengikuti Custom strategi, fungsi AWS AppSync DynamoDB memanggil fungsi Lambda untuk memutuskan apa yang harus dilakukan selanjutnya. Fungsi Lambda memilih salah satu opsi berikut:

Permintaan pemanggilan Lambda

Fungsi AWS AppSync DynamoDB memanggil fungsi Lambda yang ditentukan dalam. lambdaArn Ini menggunakan service-role-arn konfigurasi yang sama pada sumber data. Muatan pemanggilan memiliki struktur sebagai berikut:

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

Bidang didefinisikan sebagai berikut:

Contoh lengkap dari payload:

{
    "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"
    }
}

Respons Pemanggilan Lambda

Fungsi Lambda dapat memeriksa payload pemanggilan dan menerapkan logika bisnis apa pun untuk memutuskan bagaimana fungsi AWS AppSync DynamoDB harus menangani kegagalan. Ada tiga opsi untuk menangani kegagalan pemeriksaan kondisi:

Berikut adalah contoh fungsi Lambda untuk menangani PutItem permintaan yang gagal. Logika bisnis melihat siapa yang melakukan panggilan. Jika dibuat olehjeffTheAdmin, ia mencoba lagi permintaan, memperbarui version dan expectedVersion dari item yang saat ini ada di DynamoDB. Jika tidak, ia menolak mutasi.

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