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

Menggunakan operasi batch DynamoDB di AWS AppSync

AWS AppSync mendukung penggunaan operasi batch Amazon DynamoDB di satu atau beberapa tabel dalam satu Wilayah. Operasi yang didukung adalahBatchGetItem,BatchPutItem, danBatchDeleteItem. Dengan menggunakan fitur-fitur ini di AWS AppSync, Anda dapat melakukan tugas-tugas seperti:

Operasi Batch AWS AppSync memiliki dua perbedaan utama dari operasi non-batch:

Batch tabel tunggal

Untuk memulai, mari buat GraphQL API baru. Di AWS AppSync konsol, pilih Buat API, APIsGraphQL, dan Desain dari awal. Beri nama Anda APIBatchTutorial API, pilih Berikutnya, dan pada langkah Tentukan sumber daya GraphQL, pilih Buat sumber daya GraphQL nanti dan klik Berikutnya. Tinjau detail Anda dan buatAPI. Pergi ke halaman Skema dan tempel skema berikut, perhatikan bahwa untuk kueri, kami akan meneruskan daftar: IDs

type Post {
    id: ID!
    title: String
}

input PostInput {
    id: ID!
    title: String
}

type Query {
    batchGet(ids: [ID]): [Post]
}

type Mutation {
    batchAdd(posts: [PostInput]): [Post]
    batchDelete(ids: [ID]): [Post]
}

Simpan skema Anda dan pilih Buat Sumber Daya di bagian atas halaman. Pilih Gunakan tipe yang ada dan pilih Post jenisnya. Beri nama meja AndaPosts. Pastikan Primary Key diatur keid, batalkan pilihan Automatically generate GraphQL (Anda akan memberikan kode Anda sendiri), dan pilih Create. Untuk memulai, AWS AppSync buat tabel DynamoDB baru dan sumber data yang terhubung ke tabel dengan peran yang sesuai. Namun, masih ada beberapa izin yang perlu Anda tambahkan ke peran tersebut. Buka halaman Sumber data dan pilih sumber data baru. Di bawah Pilih peran yang ada, Anda akan melihat bahwa peran dibuat secara otomatis untuk tabel. Perhatikan peran (akan terlihat sepertiappsync-ds-ddb-aaabbbcccddd-Posts) dan kemudian pergi ke IAM konsol (https://console.aws.amazon.com/iam/). Di IAM konsol, pilih Peran, lalu pilih peran Anda dari tabel. Dalam peran Anda, di bawah Kebijakan izin, klik "+" di sebelah kebijakan (harus memiliki nama yang mirip dengan nama peran). Pilih Edit di bagian atas yang dapat dilipat saat kebijakan muncul. Anda perlu menambahkan izin batch ke kebijakan Anda, khususnya dynamodb:BatchGetItem dandynamodb:BatchWriteItem. Ini akan terlihat seperti ini:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "dynamodb:DeleteItem",
                "dynamodb:GetItem",
                "dynamodb:PutItem",
                "dynamodb:Query",
                "dynamodb:Scan",
                "dynamodb:UpdateItem",
                "dynamodb:BatchWriteItem",
                "dynamodb:BatchGetItem"
            ],
            "Resource": [
                "arn:aws:dynamodb:…",
                "arn:aws:dynamodb:…"
            ]
        }
    ]
}

Pilih Berikutnya, lalu Simpan perubahan. Kebijakan Anda harus mengizinkan pemrosesan batch sekarang.

Kembali ke AWS AppSync konsol, buka halaman Skema dan pilih Lampirkan di sebelah Mutation.batchAdd bidang. Buat resolver Anda menggunakan Posts tabel sebagai sumber data. Di editor kode, ganti handler dengan cuplikan di bawah ini. Cuplikan ini secara otomatis mengambil setiap item dalam input PostInput tipe GraphQL dan membuat peta, yang diperlukan untuk operasi: BatchPutItem

import { util } from "@aws-appsync/utils";

export function request(ctx) {
  return {
    operation: "BatchPutItem",
    tables: {
      Posts: ctx.args.posts.map((post) => util.dynamodb.toMapValues(post)),
    },
  };
}

export function response(ctx) {
  if (ctx.error) {
    util.error(ctx.error.message, ctx.error.type);
  }
  return ctx.result.data.Posts;
}

Arahkan ke halaman Kueri AWS AppSync konsol dan jalankan batchAdd mutasi berikut:

mutation add {
    batchAdd(posts:[{
            id: 1 title: "Running in the Park"},{
            id: 2 title: "Playing fetch"
        }]){
            id
            title
    }
}

Anda akan melihat hasil yang dicetak di layar; ini dapat divalidasi dengan meninjau konsol DynamoDB untuk memindai nilai yang ditulis ke tabel. Posts

Selanjutnya, ulangi proses melampirkan resolver tetapi untuk Query.batchGet bidang menggunakan Posts tabel sebagai sumber data. Ganti handler dengan kode di bawah ini. Ini secara otomatis mengambil setiap item dalam tipe ids:[] GraphQL dan membangun peta yang diperlukan untuk operasi: BatchGetItem

import { util } from "@aws-appsync/utils";

export function request(ctx) {
  return {
    operation: "BatchGetItem",
    tables: {
      Posts: {
        keys: ctx.args.ids.map((id) => util.dynamodb.toMapValues({ id })),
        consistentRead: true,
      },
    },
  };
}

export function response(ctx) {
  if (ctx.error) {
    util.error(ctx.error.message, ctx.error.type);
  }
  return ctx.result.data.Posts;
}

Sekarang, kembali ke halaman Queries AWS AppSync konsol dan jalankan batchGet kueri berikut:

query get {
    batchGet(ids:[1,2,3]){
        id
        title
    }
}

Ini akan mengembalikan hasil untuk dua id nilai yang Anda tambahkan sebelumnya. Perhatikan bahwa null nilai dikembalikan untuk id dengan nilai3. Ini karena belum ada catatan di Posts tabel Anda dengan nilai itu. Perhatikan juga bahwa AWS AppSync mengembalikan hasil dalam urutan yang sama dengan kunci yang diteruskan ke kueri, yang merupakan fitur tambahan yang AWS AppSync berkinerja atas nama Anda. Jadi, jika Anda beralih kebatchGet(ids:[1,3,2]), Anda akan melihat bahwa urutannya berubah. Anda juga akan tahu mana yang id mengembalikan null nilai.

Terakhir, lampirkan satu resolver lagi ke Mutation.batchDelete bidang menggunakan Posts tabel sebagai sumber data. Ganti handler dengan kode di bawah ini. Ini secara otomatis mengambil setiap item dalam tipe ids:[] GraphQL dan membangun peta yang diperlukan untuk operasi: BatchGetItem

import { util } from "@aws-appsync/utils";

export function request(ctx) {
  return {
    operation: "BatchDeleteItem",
    tables: {
      Posts: ctx.args.ids.map((id) => util.dynamodb.toMapValues({ id })),
    },
  };
}

export function response(ctx) {
  if (ctx.error) {
    util.error(ctx.error.message, ctx.error.type);
  }
  return ctx.result.data.Posts;
}

Sekarang, kembali ke halaman Queries AWS AppSync konsol dan jalankan batchDelete mutasi berikut:

mutation delete {
    batchDelete(ids:[1,2]){ id }
}

Catatan dengan id 1 dan sekarang 2 harus dihapus. Jika Anda menjalankan kembali batchGet() kueri dari sebelumnya, ini akan kembalinull.

Batch multi-tabel

AWS AppSync juga memungkinkan Anda untuk melakukan operasi batch di seluruh tabel. Mari kita membangun aplikasi yang lebih kompleks. Bayangkan kita sedang membangun aplikasi kesehatan hewan peliharaan di mana sensor melaporkan lokasi dan suhu tubuh hewan peliharaan. Sensor bertenaga baterai dan mencoba untuk terhubung ke jaringan setiap beberapa menit. Ketika sensor membuat koneksi, ia mengirimkan bacaannya ke kami AWS AppSync API. Pemicu kemudian menganalisis data sehingga dasbor dapat disajikan kepada pemilik hewan peliharaan. Mari kita fokus pada merepresentasikan interaksi antara sensor dan penyimpanan data backend.

Di AWS AppSync konsol, pilih Buat API, APIsGraphQL, dan Desain dari awal. Beri nama Anda APIMultiBatchTutorial API, pilih Berikutnya, dan pada langkah Tentukan sumber daya GraphQL, pilih Buat sumber daya GraphQL nanti dan klik Berikutnya. Tinjau detail Anda dan buatAPI. Buka halaman Skema dan tempel dan simpan skema berikut:

type Mutation {
    # Register a batch of readings
    recordReadings(tempReadings: [TemperatureReadingInput], locReadings: [LocationReadingInput]): RecordResult
    # Delete a batch of readings
    deleteReadings(tempReadings: [TemperatureReadingInput], locReadings: [LocationReadingInput]): RecordResult
}

type Query {
    # Retrieve all possible readings recorded by a sensor at a specific time
    getReadings(sensorId: ID!, timestamp: String!): [SensorReading]
}

type RecordResult {
    temperatureReadings: [TemperatureReading]
    locationReadings: [LocationReading]
}

interface SensorReading {
    sensorId: ID!
    timestamp: String!
}

# Sensor reading representing the sensor temperature (in Fahrenheit)
type TemperatureReading implements SensorReading {
    sensorId: ID!
    timestamp: String!
    value: Float
}

# Sensor reading representing the sensor location (lat,long)
type LocationReading implements SensorReading {
    sensorId: ID!
    timestamp: String!
    lat: Float
    long: Float
}

input TemperatureReadingInput {
    sensorId: ID!
    timestamp: String
    value: Float
}

input LocationReadingInput {
    sensorId: ID!
    timestamp: String
    lat: Float
    long: Float
}

Kita perlu membuat dua tabel DynamoDB:

Kedua tabel akan berbagi struktur kunci primer yang sama: sensorId (String) sebagai kunci partisi dan timestamp (String) sebagai kunci sortir.

Pilih Buat Sumber Daya di bagian atas halaman. Pilih Gunakan tipe yang ada dan pilih locationReadings jenisnya. Beri nama meja AndalocationReadings. Pastikan Primary Key diatur ke sensorId dan tombol sortir ketimestamp. Hapus pilihan Secara otomatis menghasilkan GraphQL (Anda akan memberikan kode Anda sendiri), dan pilih Buat. Ulangi proses ini untuk temperatureReadings menggunakan temperatureReadings sebagai tipe dan nama tabel. Gunakan tombol yang sama seperti di atas.

Tabel baru Anda akan berisi peran yang dihasilkan secara otomatis. Masih ada beberapa izin yang perlu Anda tambahkan ke peran tersebut. Buka halaman Sumber data dan pilihlocationReadings. Di bawah Pilih peran yang ada, Anda dapat melihat peran tersebut. Perhatikan peran (akan terlihat sepertiappsync-ds-ddb-aaabbbcccddd-locationReadings) dan kemudian pergi ke IAM konsol (https://console.aws.amazon.com/iam/). Di IAM konsol, pilih Peran, lalu pilih peran Anda dari tabel. Dalam peran Anda, di bawah Kebijakan izin, klik "+" di sebelah kebijakan (harus memiliki nama yang mirip dengan nama peran). Pilih Edit di bagian atas yang dapat dilipat saat kebijakan muncul. Anda perlu menambahkan izin ke kebijakan ini. Ini akan terlihat seperti ini:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "dynamodb:DeleteItem",
                "dynamodb:GetItem",
                "dynamodb:PutItem",
                "dynamodb:Query",
                "dynamodb:Scan",
                "dynamodb:UpdateItem",
                "dynamodb:BatchGetItem",
                "dynamodb:BatchWriteItem"
            ],
            "Resource": [
                "arn:aws:dynamodb:region:account:table/locationReadings",
                "arn:aws:dynamodb:region:account:table/locationReadings/*",
                "arn:aws:dynamodb:region:account:table/temperatureReadings",
                "arn:aws:dynamodb:region:account:table/temperatureReadings/*"
            ]
        }
    ]
}

Pilih Berikutnya, lalu Simpan perubahan. Ulangi proses ini untuk sumber temperatureReadings data menggunakan cuplikan kebijakan yang sama di atas.

BatchPutItem - Merekam pembacaan sensor

Sensor kami harus dapat mengirim bacaan mereka setelah mereka terhubung ke internet. Mutation.recordReadingsBidang GraphQL adalah yang akan mereka gunakan API untuk melakukannya. Kita perlu menambahkan resolver ke bidang ini.

Di halaman Skema AWS AppSync konsol, pilih Lampirkan di sebelah Mutation.recordReadings bidang. Pada layar berikutnya, buat resolver Anda menggunakan locationReadings tabel sebagai sumber data.

Setelah membuat resolver Anda, ganti handler dengan kode berikut di editor. BatchPutItemOperasi ini memungkinkan kita untuk menentukan beberapa tabel:

import { util } from '@aws-appsync/utils'

export function request(ctx) {
	const { locReadings, tempReadings } = ctx.args
	const locationReadings = locReadings.map((loc) => util.dynamodb.toMapValues(loc))
	const temperatureReadings = tempReadings.map((tmp) => util.dynamodb.toMapValues(tmp))

	return {
		operation: 'BatchPutItem',
		tables: {
			locationReadings,
			temperatureReadings,
		},
	}
}

export function response(ctx) {
	if (ctx.error) {
		util.appendError(ctx.error.message, ctx.error.type)
	}
	return ctx.result.data
}

Dengan operasi batch, mungkin ada kesalahan dan hasil yang dikembalikan dari pemanggilan. Dalam hal ini, kami bebas melakukan beberapa penanganan kesalahan tambahan.

Simpan resolver dan navigasikan ke halaman Kueri di konsol. AWS AppSync Kami sekarang dapat mengirim beberapa pembacaan sensor.

Jalankan mutasi berikut:

mutation sendReadings {
  recordReadings(
    tempReadings: [
      {sensorId: 1, value: 85.5, timestamp: "2018-02-01T17:21:05.000+08:00"},
      {sensorId: 1, value: 85.7, timestamp: "2018-02-01T17:21:06.000+08:00"},
      {sensorId: 1, value: 85.8, timestamp: "2018-02-01T17:21:07.000+08:00"},
      {sensorId: 1, value: 84.2, timestamp: "2018-02-01T17:21:08.000+08:00"},
      {sensorId: 1, value: 81.5, timestamp: "2018-02-01T17:21:09.000+08:00"}
    ]
    locReadings: [
      {sensorId: 1, lat: 47.615063, long: -122.333551, timestamp: "2018-02-01T17:21:05.000+08:00"},
      {sensorId: 1, lat: 47.615163, long: -122.333552, timestamp: "2018-02-01T17:21:06.000+08:00"},
      {sensorId: 1, lat: 47.615263, long: -122.333553, timestamp: "2018-02-01T17:21:07.000+08:00"},
      {sensorId: 1, lat: 47.615363, long: -122.333554, timestamp: "2018-02-01T17:21:08.000+08:00"},
      {sensorId: 1, lat: 47.615463, long: -122.333555, timestamp: "2018-02-01T17:21:09.000+08:00"}
    ]) {
    locationReadings {
      sensorId
      timestamp
      lat
      long
    }
    temperatureReadings {
      sensorId
      timestamp
      value
    }
  }
}

Kami mengirim sepuluh pembacaan sensor dalam satu mutasi dengan pembacaan dibagi menjadi dua tabel. Gunakan konsol DynamoDB untuk memvalidasi bahwa data muncul di tabel dan tabel. locationReadings temperatureReadings

BatchDeleteItem - Menghapus pembacaan sensor

Demikian pula, kita juga harus dapat menghapus batch pembacaan sensor. Mari kita gunakan bidang Mutation.deleteReadings GraphQL untuk tujuan ini. Di halaman Skema AWS AppSync konsol, pilih Lampirkan di sebelah Mutation.deleteReadings bidang. Pada layar berikutnya, buat resolver Anda menggunakan locationReadings tabel sebagai sumber data.

Setelah membuat resolver Anda, ganti handler di editor kode dengan cuplikan di bawah ini. Dalam resolver ini, kita menggunakan helper function mapper yang mengekstrak sensorId dan timestamp dari input yang disediakan.

import { util } from '@aws-appsync/utils'

export function request(ctx) {
	const { locReadings, tempReadings } = ctx.args
	const mapper = ({ sensorId, timestamp }) => util.dynamodb.toMapValues({ sensorId, timestamp })

	return {
		operation: 'BatchDeleteItem',
		tables: {
			locationReadings: locReadings.map(mapper),
			temperatureReadings: tempReadings.map(mapper),
		},
	}
}

export function response(ctx) {
	if (ctx.error) {
		util.appendError(ctx.error.message, ctx.error.type)
	}
	return ctx.result.data
}

Simpan resolver dan navigasikan ke halaman Kueri di konsol. AWS AppSync Sekarang, mari kita hapus beberapa pembacaan sensor.

Jalankan mutasi berikut:

mutation deleteReadings {
  # Let's delete the first two readings we recorded
  deleteReadings(
    tempReadings: [{sensorId: 1, timestamp: "2018-02-01T17:21:05.000+08:00"}]
    locReadings: [{sensorId: 1, timestamp: "2018-02-01T17:21:05.000+08:00"}]) {
    locationReadings {
      sensorId
      timestamp
      lat
      long
    }
    temperatureReadings {
      sensorId
      timestamp
      value
    }
  }
}

Validasi melalui konsol DynamoDB bahwa kedua pembacaan ini telah dihapus dari tabel dan. locationReadings temperatureReadings

BatchGetItem - Ambil bacaan

Operasi umum lainnya untuk aplikasi kami adalah mengambil pembacaan untuk sensor pada titik waktu tertentu. Mari kita lampirkan resolver ke bidang GraphQL pada Query.getReadings skema kita. Di halaman Skema AWS AppSync konsol, pilih Lampirkan di sebelah Query.getReadings bidang. Pada layar berikutnya, buat resolver Anda menggunakan locationReadings tabel sebagai sumber data.

Mari kita gunakan kode berikut:

import { util } from '@aws-appsync/utils'

export function request(ctx) {
	const keys = [util.dynamodb.toMapValues(ctx.args)]
	const consistentRead = true
	return {
		operation: 'BatchGetItem',
		tables: {
			locationReadings: { keys, consistentRead },
			temperatureReadings: { keys, consistentRead },
		},
	}
}

export function response(ctx) {
	if (ctx.error) {
		util.appendError(ctx.error.message, ctx.error.type)
	}
	const { locationReadings: locs, temperatureReadings: temps } = ctx.result.data

	return [
		...locs.map((l) => ({ ...l, __typename: 'LocationReading' })),
		...temps.map((t) => ({ ...t, __typename: 'TemperatureReading' })),
	]
}

Simpan resolver dan navigasikan ke halaman Kueri di konsol. AWS AppSync Sekarang, mari kita ambil pembacaan sensor kita.

Jalankan kueri berikut:

query getReadingsForSensorAndTime {
  # Let's retrieve the very first two readings
  getReadings(sensorId: 1, timestamp: "2018-02-01T17:21:06.000+08:00") {
    sensorId
    timestamp
    ...on TemperatureReading {
      value
    }
    ...on LocationReading {
      lat
      long
    }
  }
}

Kami telah berhasil mendemonstrasikan penggunaan operasi batch DynamoDB menggunakan. AWS AppSync

Penanganan kesalahan

Dalam AWS AppSync, operasi sumber data terkadang dapat mengembalikan hasil sebagian. Hasil sebagian adalah istilah yang akan kita gunakan untuk menunjukkan ketika output dari suatu operasi terdiri dari beberapa data dan kesalahan. Karena penanganan kesalahan secara inheren spesifik aplikasi, AWS AppSync memberi Anda kesempatan untuk menangani kesalahan dalam penangan respons. Kesalahan pemanggilan resolver, jika ada, tersedia dari konteks sebagai. ctx.error Kesalahan pemanggilan selalu menyertakan pesan dan tipe, dapat diakses sebagai properti ctx.error.message dan. ctx.error.type Dalam handler respon, Anda dapat menangani sebagian hasil dalam tiga cara:

Mari kita tunjukkan masing-masing dari tiga poin di atas dengan operasi batch DynamoDB.

Operasi Batch DynamoDB

Dengan operasi batch DynamoDB, ada kemungkinan bahwa batch sebagian selesai. Artinya, ada kemungkinan bahwa beberapa item atau kunci yang diminta dibiarkan tidak diproses. Jika AWS AppSync tidak dapat menyelesaikan batch, item yang belum diproses dan kesalahan pemanggilan akan disetel pada konteksnya.

Kami akan menerapkan penanganan kesalahan menggunakan konfigurasi Query.getReadings bidang dari BatchGetItem operasi dari bagian sebelumnya dari tutorial ini. Kali ini, mari kita berpura-pura bahwa saat mengeksekusi Query.getReadings field, tabel DynamoDB temperatureReadings kehabisan throughput yang disediakan. DynamoDB mengangkat ProvisionedThroughputExceededException a selama upaya kedua AWS AppSync dengan memproses elemen yang tersisa dalam batch.

Berikut ini JSON merupakan konteks serial setelah pemanggilan batch DynamoDB tetapi sebelum penangan respons dipanggil:

{
  "arguments": {
    "sensorId": "1",
    "timestamp": "2018-02-01T17:21:05.000+08:00"
  },
  "source": null,
  "result": {
    "data": {
      "temperatureReadings": [
        null
      ],
      "locationReadings": [
        {
          "lat": 47.615063,
          "long": -122.333551,
          "sensorId": "1",
          "timestamp": "2018-02-01T17:21:05.000+08:00"
        }
      ]
    },
    "unprocessedKeys": {
      "temperatureReadings": [
        {
          "sensorId": "1",
          "timestamp": "2018-02-01T17:21:05.000+08:00"
        }
      ],
      "locationReadings": []
    }
  },
  "error": {
    "type": "DynamoDB:ProvisionedThroughputExceededException",
    "message": "You exceeded your maximum allowed provisioned throughput for a table or for one or more global secondary indexes. (...)"
  },
  "outErrors": []
}

Beberapa hal yang perlu diperhatikan pada konteksnya:

Mari kita tangani kesalahan ini dengan tiga cara berbeda.

1. Menelan kesalahan pemanggilan

Mengembalikan data tanpa menangani kesalahan pemanggilan secara efektif menelan kesalahan, membuat hasil untuk bidang GraphQL yang diberikan selalu berhasil.

Kode yang kami tulis sudah tidak asing lagi dan hanya berfokus pada data hasil.

Penangan respons

export function response(ctx) {
  return ctx.result.data
}

Tanggapan GraphQL

{
  "data": {
    "getReadings": [
      {
        "sensorId": "1",
        "timestamp": "2018-02-01T17:21:05.000+08:00",
        "lat": 47.615063,
        "long": -122.333551
      },
      {
        "sensorId": "1",
        "timestamp": "2018-02-01T17:21:05.000+08:00",
        "value": 85.5
      }
    ]
  }
}

Tidak ada kesalahan yang akan ditambahkan ke respons kesalahan karena hanya data yang ditindaklanjuti.

2. Memunculkan kesalahan untuk membatalkan eksekusi handler respons

Ketika kegagalan sebagian harus diperlakukan sebagai kegagalan total dari perspektif klien, Anda dapat membatalkan eksekusi handler respons untuk mencegah pengembalian data. Metode util.error(...) utilitas mencapai perilaku ini dengan tepat.

Kode penangan respons

export function response(ctx) {
  if (ctx.error) {
    util.error(ctx.error.message, ctx.error.type, null, ctx.result.data.unprocessedKeys);
  }
  return ctx.result.data;
}

Tanggapan GraphQL

{
  "data": {
    "getReadings": null
  },
  "errors": [
    {
      "path": [
        "getReadings"
      ],
      "data": null,
      "errorType": "DynamoDB:ProvisionedThroughputExceededException",
      "errorInfo": {
        "temperatureReadings": [
          {
            "sensorId": "1",
            "timestamp": "2018-02-01T17:21:05.000+08:00"
          }
        ],
        "locationReadings": []
      },
      "locations": [
        {
          "line": 58,
          "column": 3
        }
      ],
      "message": "You exceeded your maximum allowed provisioned throughput for a table or for one or more global secondary indexes. (...)"
    }
  ]
}

Meskipun beberapa hasil mungkin telah dikembalikan dari operasi batch DynamoDB, kami memilih untuk memunculkan kesalahan sehingga bidang getReadings GraphQL adalah nol dan kesalahan telah ditambahkan ke blok kesalahan respons GraphQL.

3. Menambahkan kesalahan untuk mengembalikan data dan kesalahan

Dalam kasus tertentu, untuk memberikan pengalaman pengguna yang lebih baik, aplikasi dapat mengembalikan sebagian hasil dan memberi tahu klien mereka tentang item yang belum diproses. Klien dapat memutuskan untuk menerapkan coba lagi atau menerjemahkan kesalahan kembali ke pengguna akhir. Ini util.appendError(...) adalah metode utilitas yang memungkinkan perilaku ini dengan membiarkan perancang aplikasi menambahkan kesalahan pada konteks tanpa mengganggu evaluasi penangan respons. Setelah mengevaluasi penangan respons, AWS AppSync akan memproses kesalahan konteks apa pun dengan menambahkannya ke blok kesalahan respons GraphQL.

Kode penangan respons

export function response(ctx) {
  if (ctx.error) {
    util.appendError(ctx.error.message, ctx.error.type, null, ctx.result.data.unprocessedKeys);
  }
  return ctx.result.data;
}

Kami meneruskan kesalahan pemanggilan dan unprocessedKeys elemen di dalam blok kesalahan respons GraphQL. getReadingsBidang ini juga mengembalikan sebagian data dari locationReadings tabel seperti yang Anda lihat pada respons di bawah ini.

Tanggapan GraphQL

{
  "data": {
    "getReadings": [
      null,
      {
        "sensorId": "1",
        "timestamp": "2018-02-01T17:21:05.000+08:00",
        "value": 85.5
      }
    ]
  },
  "errors": [
    {
      "path": [
        "getReadings"
      ],
      "data": null,
      "errorType": "DynamoDB:ProvisionedThroughputExceededException",
      "errorInfo": {
        "temperatureReadings": [
          {
            "sensorId": "1",
            "timestamp": "2018-02-01T17:21:05.000+08:00"
          }
        ],
        "locationReadings": []
      },
      "locations": [
        {
          "line": 58,
          "column": 3
        }
      ],
      "message": "You exceeded your maximum allowed provisioned throughput for a table or for one or more global secondary indexes. (...)"
    }
  ]
}