Membuat aplikasi posting sederhana menggunakan DynamoDB resolvers JavaScript - AWS AppSync GraphQL
Membuat GraphQL APIMendefinisikan posting dasar APIMenyiapkan tabel Amazon DynamoDB AndaMenyiapkan addPost resolver (Amazon DynamoDB) PutItemMenyiapkan getPost resolver (Amazon DynamoDB) GetItemBuat updatePost mutasi (Amazon DynamoDB UpdateItem)Buat mutasi suara (Amazon DynamoDB UpdateItem)Menyiapkan deletePost resolver (Amazon DynamoDB) DeleteItemMenyiapkan allPost resolver (Amazon DynamoDB Scan)Menyiapkan resolver allPostsBy Penulis (Amazon DynamoDB Query)Menggunakan setKesimpulan

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

Membuat aplikasi posting sederhana menggunakan DynamoDB resolvers JavaScript

Dalam tutorial ini, Anda akan mengimpor tabel Amazon DynamoDB Anda dan menghubungkannya AWS AppSync untuk membangun GraphQL yang berfungsi penuh JavaScript menggunakan resolver pipeline yang dapat Anda API manfaatkan dalam aplikasi Anda sendiri.

Anda akan menggunakan AWS AppSync konsol untuk menyediakan sumber daya Amazon DynamoDB, membuat resolver, dan menghubungkannya ke sumber data Anda. Anda juga akan dapat membaca dan menulis ke database Amazon DynamoDB Anda melalui pernyataan GraphQL dan berlangganan data waktu nyata.

Ada langkah-langkah khusus yang harus diselesaikan agar pernyataan GraphQL diterjemahkan ke operasi Amazon DynamoDB dan agar tanggapan diterjemahkan kembali ke GraphQL. Tutorial ini menguraikan proses konfigurasi melalui beberapa skenario dunia nyata dan pola akses data.

Membuat GraphQL API

Untuk membuat GraphQL API di AWS AppSync

  1. Buka AppSync konsol dan pilih Buat API.

  2. Pilih Desain dari awal dan pilih Berikutnya.

  3. Beri nama Anda APIPostTutorialAPI, lalu pilih Berikutnya. Lewati ke halaman ulasan sambil menjaga opsi lainnya disetel ke nilai defaultnya dan pilihCreate.

AWS AppSync Konsol membuat API GraphQL baru untuk Anda. Dengan detault, itu menggunakan mode otentikasi API kunci. Anda dapat menggunakan konsol untuk mengatur sisa API GraphQL dan menjalankan kueri terhadapnya selama sisa tutorial ini.

Mendefinisikan posting dasar API

Sekarang setelah Anda memiliki API GraphQL, Anda dapat mengatur skema dasar yang memungkinkan pembuatan dasar, pengambilan, dan penghapusan data posting.

Untuk menambahkan data ke skema Anda

  1. Di tab AndaAPI, pilih tab Skema.

  2. Kami akan membuat skema yang mendefinisikan Post tipe dan operasi addPost untuk menambah dan mendapatkan Post objek. Di panel Skema, ganti konten dengan kode berikut:

    schema {
    query: Query
    mutation: Mutation
}

type Query {
    getPost(id: ID): Post
}

type Mutation {
    addPost(
        id: ID!
        author: String!
        title: String!
        content: String!
        url: String!
    ): Post!
}

type Post {
    id: ID!
    author: String
    title: String
    content: String
    url: String
    ups: Int!
    downs: Int!
    version: Int!
}

  3. Pilih Simpan Skema.

Menyiapkan tabel Amazon DynamoDB Anda

AWS AppSync Konsol dapat membantu menyediakan AWS sumber daya yang diperlukan untuk menyimpan sumber daya Anda sendiri di tabel Amazon DynamoDB. Pada langkah ini, Anda akan membuat tabel Amazon DynamoDB untuk menyimpan posting Anda. Anda juga akan menyiapkan indeks sekunder yang akan kita gunakan nanti.

Untuk membuat tabel Amazon DynamoDB Anda

  1. Pada halaman Skema, pilih Buat Sumber Daya.

  2. Pilih Gunakan tipe yang ada, lalu pilih Post jenisnya.

  3. Di bagian Indeks Tambahan, pilih Tambah Indeks.

  4. Beri nama indeksnyaauthor-index.

  5. Atur Primary key ke author dan Sort kunci keNone.

  6. Nonaktifkan Secara otomatis menghasilkan GraphQL. Dalam contoh ini, kita akan membuat resolver sendiri.

  7. Pilih Buat.

Anda sekarang memiliki sumber data baru yang disebutPostTable, yang dapat Anda lihat dengan mengunjungi Sumber data di tab samping. Anda akan menggunakan sumber data ini untuk menautkan kueri dan mutasi Anda ke tabel Amazon DynamoDB Anda.

Menyiapkan addPost resolver (Amazon DynamoDB) PutItem

Sekarang AWS AppSync mengetahui tabel Amazon DynamoDB, Anda dapat menautkannya ke kueri dan mutasi individual dengan mendefinisikan resolver. Resolver pertama yang Anda buat adalah resolver addPost pipeline yang digunakan JavaScript, yang memungkinkan Anda membuat postingan di tabel Amazon DynamoDB Anda. Pipeline resolver memiliki komponen-komponen berikut:

  • Lokasi dalam skema GraphQL untuk melampirkan resolver. Dalam hal ini, Anda menyiapkan resolver di createPost bidang pada tipe. Mutation Penyelesai ini akan dipanggil saat pemanggil memanggil mutasi. { addPost(...){...} }

  • Sumber data yang akan digunakan untuk resolver ini. Dalam hal ini, Anda ingin menggunakan sumber data DynamoDB yang Anda tentukan sebelumnya, sehingga Anda dapat menambahkan entri ke dalam post-table-for-tutorial tabel DynamoDB.

  • Penangan permintaan. Handler permintaan adalah fungsi yang menangani permintaan masuk dari pemanggil dan menerjemahkannya ke dalam instruksi untuk AWS AppSync melakukan terhadap DynamoDB.

  • Penangan respons. Tugas penangan respons adalah menangani respons dari DynamoDB dan menerjemahkannya kembali menjadi sesuatu yang diharapkan GraphQL. Ini berguna jika bentuk data di DynamoDB berbeda dengan Post tipe di GraphQL, tetapi dalam hal ini mereka memiliki bentuk yang sama, jadi Anda cukup melewatkan data.

Untuk mengatur resolver Anda

  1. Di tab AndaAPI, pilih tab Skema.

  2. Di panel Resolvers, temukan addPost bidang di bawah Mutation tipe, lalu pilih Lampirkan.

  3. Pilih sumber data Anda, lalu pilih Buat.

  4. Di editor kode Anda, ganti kode dengan cuplikan ini:

    import { util } from '@aws-appsync/utils'
import * as ddb from '@aws-appsync/utils/dynamodb'

export function request(ctx) {
	const item = { ...ctx.arguments, ups: 1, downs: 0, version: 1 }
	const key = { id: ctx.args.id ?? util.autoId() }
	return ddb.put({ key, item })
}

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

  5. Pilih Simpan.

catatan

Dalam kode ini, Anda menggunakan utilitas modul DynamoDB yang memungkinkan Anda untuk dengan mudah membuat permintaan DynamoDB.

AWS AppSync dilengkapi dengan utilitas untuk pembuatan ID otomatis yang disebututil.autoId(), yang digunakan untuk menghasilkan ID untuk posting baru Anda. Jika Anda tidak menentukan ID, utilitas akan secara otomatis menghasilkannya untuk Anda.

const key = { id: ctx.args.id ?? util.autoId() }

Untuk informasi selengkapnya tentang utilitas yang tersedia JavaScript, lihat fitur JavaScript runtime untuk resolver dan fungsi.

Panggil API untuk menambahkan posting

Sekarang resolver telah dikonfigurasi, AWS AppSync dapat menerjemahkan addPost mutasi yang masuk ke operasi Amazon DynamoDB. PutItem Anda sekarang dapat menjalankan mutasi untuk meletakkan sesuatu di tabel.

Untuk menjalankan operasi

  1. Di tab AndaAPI, pilih tab Kueri.

  2. Di panel Kueri, tambahkan mutasi berikut:

    mutation addPost {
  addPost(
    id: 123,
    author: "AUTHORNAME"
    title: "Our first post!"
    content: "This is our first post."
    url: "https://aws.amazon.com/appsync/"
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

  3. Pilih Run (tombol putar oranye), lalu pilihaddPost. Hasil posting yang baru dibuat akan muncul di panel Hasil di sebelah kanan panel Kueri. Itu terlihat serupa dengan yang berikut ini:

    {
  "data": {
    "addPost": {
      "id": "123",
      "author": "AUTHORNAME",
      "title": "Our first post!",
      "content": "This is our first post.",
      "url": "https://aws.amazon.com/appsync/",
      "ups": 1,
      "downs": 0,
      "version": 1
    }
  }
}

Penjelasan berikut menunjukkan apa yang terjadi:

  1. AWS AppSync menerima permintaan addPost mutasi.

  2. AWS AppSync mengeksekusi penangan permintaan dari resolver. ddb.putFungsi membuat PutItem permintaan yang terlihat seperti ini:

    {
  operation: 'PutItem',
  key: { id: { S: '123' } },
  attributeValues: {
    downs: { N: 0 },
    author: { S: 'AUTHORNAME' },
    ups: { N: 1 },
    title: { S: 'Our first post!' },
    version: { N: 1 },
    content: { S: 'This is our first post.' },
    url: { S: 'https://aws.amazon.com/appsync/' }
  }
}

  3. AWS AppSync menggunakan nilai ini untuk menghasilkan dan menjalankan permintaan Amazon PutItem DynamoDB.

  4. AWS AppSync mengambil hasil PutItem permintaan dan mengubahnya kembali ke tipe GraphQL.

    {
    "id" : "123",
    "author": "AUTHORNAME",
    "title": "Our first post!",
    "content": "This is our first post.",
    "url": "https://aws.amazon.com/appsync/",
    "ups" : 1,
    "downs" : 0,
    "version" : 1
}

  5. Response handler mengembalikan hasilnya segera (return ctx.result).

  6. Hasil akhir terlihat dalam respons GraphQL.

Menyiapkan getPost resolver (Amazon DynamoDB) GetItem

Sekarang Anda dapat menambahkan data ke tabel Amazon DynamoDB, Anda perlu mengatur kueri sehingga getPost dapat mengambil data itu dari tabel. Untuk melakukan ini, Anda mengatur resolver lain.

Untuk menambahkan resolver Anda

  1. Di tab AndaAPI, pilih tab Skema.

  2. Di panel Resolvers di sebelah kanan, temukan getPost bidang pada Query jenis dan kemudian pilih Lampirkan.

  3. Pilih sumber data Anda, lalu pilih Buat.

  4. Di editor kode, ganti kode dengan cuplikan ini:

    import * as ddb from '@aws-appsync/utils/dynamodb'
	
export function request(ctx) {
	return ddb.get({ key: { id: ctx.args.id } })
}

export const response = (ctx) => ctx.result

  5. Simpan resolver Anda.

catatan

Dalam resolver ini, kita menggunakan ekspresi fungsi panah untuk handler respon.

Hubungi API untuk mendapatkan posting

Sekarang resolver telah diatur, AWS AppSync tahu cara menerjemahkan getPost kueri masuk ke operasi Amazon DynamoDB. GetItem Anda sekarang dapat menjalankan kueri untuk mengambil posting yang Anda buat sebelumnya.

Untuk menjalankan kueri

  1. Di tab AndaAPI, pilih tab Kueri.

  2. Di panel Kueri, tambahkan kode berikut, dan gunakan id yang Anda salin setelah membuat posting Anda:

    query getPost {
  getPost(id: "123") {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

  3. Pilih Run (tombol putar oranye), lalu pilihgetPost. Hasil posting yang baru dibuat akan muncul di panel Hasil di sebelah kanan panel Kueri.

  4. Postingan yang diambil dari Amazon DynamoDB akan muncul di panel Hasil di sebelah kanan panel Kueri. Itu terlihat serupa dengan yang berikut ini:

    {
  "data": {
    "getPost": {
      "id": "123",
      "author": "AUTHORNAME",
      "title": "Our first post!",
      "content": "This is our first post.",
      "url": "https://aws.amazon.com/appsync/",
      "ups": 1,
      "downs": 0,
      "version": 1
    }
  }
}

Atau, ambil contoh berikut:

query getPost {
  getPost(id: "123") {
    id
    author
    title
  }
}

Jika getPost kueri Anda hanya membutuhkanid,, dan authortitle, Anda dapat mengubah fungsi permintaan Anda untuk menggunakan ekspresi proyeksi untuk menentukan hanya atribut yang Anda inginkan dari tabel DynamoDB Anda untuk menghindari transfer data yang tidak perlu dari DynamoDB ke. AWS AppSync Misalnya, fungsi permintaan mungkin terlihat seperti cuplikan di bawah ini:

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

export function request(ctx) {
	return ddb.get({
		key: { id: ctx.args.id },
		projection: ['author', 'id', 'title'],
	})
}

export const response = (ctx) => ctx.result

Anda juga dapat menggunakan selectionSetListwith getPost untuk mewakiliexpression:

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

export function request(ctx) {
	const projection = ctx.info.selectionSetList.map((field) => field.replace('/', '.'))
	return ddb.get({ key: { id: ctx.args.id }, projection })
}

export const response = (ctx) => ctx.result

Buat updatePost mutasi (Amazon DynamoDB UpdateItem)

Sejauh ini, Anda dapat membuat dan mengambil Post objek di Amazon DynamoDB. Selanjutnya, Anda akan menyiapkan mutasi baru untuk memperbarui objek. Dibandingkan dengan addPost mutasi yang mengharuskan semua bidang ditentukan, mutasi ini memungkinkan Anda untuk hanya menentukan bidang yang ingin Anda ubah. Ini juga memperkenalkan expectedVersion argumen baru yang memungkinkan Anda menentukan versi yang ingin Anda modifikasi. Anda akan mengatur kondisi yang memastikan bahwa Anda memodifikasi versi terbaru dari objek. Anda akan melakukan ini menggunakan operasi UpdateItem Amazon DynamoD.sc

Untuk memperbarui resolver Anda

  1. Di tab AndaAPI, pilih tab Skema.

  2. Di panel Skema, ubah Mutation tipe untuk menambahkan updatePost mutasi baru sebagai berikut:

    type Mutation {
    updatePost(
        id: ID!,
        author: String,
        title: String,
        content: String,
        url: String,
        expectedVersion: Int!
    ): Post
    
    addPost(
        id: ID
        author: String!
        title: String!
        content: String!
        url: String!
    ): Post!
}

  3. Pilih Simpan Skema.

  4. Di panel Resolvers di sebelah kanan, temukan updatePost bidang yang baru dibuat pada Mutation jenisnya, lalu pilih Lampirkan. Buat resolver baru Anda menggunakan cuplikan di bawah ini:

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

export function request(ctx) {
  const { id, expectedVersion, ...rest } = ctx.args;
  const values = Object.entries(rest).reduce((obj, [key, value]) => {
    obj[key] = value ?? ddb.operations.remove();
    return obj;
  }, {});

  return ddb.update({
    key: { id },
    condition: { version: { eq: expectedVersion } },
    update: { ...values, version: ddb.operations.increment(1) },
  });
}

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

  5. Simpan semua perubahan yang Anda buat.

Resolver ini digunakan ddb.update untuk membuat permintaan Amazon DynamoDB. UpdateItem Alih-alih menulis seluruh item, Anda hanya meminta Amazon DynamoDB untuk memperbarui atribut tertentu. Ini dilakukan dengan menggunakan ekspresi pembaruan Amazon DynamoDB.

ddb.updateFungsi mengambil kunci dan objek update sebagai argumen. Kemudian, Anda memeriksa nilai-nilai argumen yang masuk. Ketika nilai diatur kenull, gunakan operasi remove DynamoDB untuk memberi sinyal bahwa nilai harus dihapus dari item DynamoDB.

Ada juga condition bagian baru. Ekspresi kondisi memungkinkan Anda memberi tahu AWS AppSync dan Amazon DynamoDB apakah permintaan harus berhasil atau tidak berdasarkan status objek yang sudah ada di Amazon DynamoDB sebelum operasi dilakukan. Dalam hal ini, Anda hanya ingin UpdateItem permintaan berhasil jika version bidang item yang saat ini ada di Amazon DynamoDB sama persis dengan expectedVersion argumen. Ketika item diperbarui, kami ingin menambah nilai. version Ini mudah dilakukan dengan fungsi operasiincrement.

Untuk informasi selengkapnya tentang ekspresi kondisi, lihat dokumentasi Ekspresi kondisi.

Untuk info selengkapnya tentang UpdateItem permintaan, lihat UpdateItemdokumentasi dan dokumentasi modul DynamoDB.

Untuk informasi selengkapnya tentang cara menulis ekspresi pembaruan, lihat dokumentasi DynamoDB UpdateExpressions.

Hubungi API untuk memperbarui posting

Mari kita coba memperbarui Post objek dengan resolver baru.

Untuk memperbarui objek Anda

  1. Di tab AndaAPI, pilih tab Kueri.

  2. Di panel Kueri, tambahkan mutasi berikut. Anda juga perlu memperbarui id argumen ke nilai yang Anda catat sebelumnya:

    mutation updatePost {
  updatePost(
    id:123
    title: "An empty story"
    content: null
    expectedVersion: 1
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

  3. Pilih Run (tombol putar oranye), lalu pilihupdatePost.

  4. Posting yang diperbarui di Amazon DynamoDB akan muncul di panel Hasil di sebelah kanan panel Kueri. Itu terlihat serupa dengan yang berikut ini:

    {
  "data": {
    "updatePost": {
      "id": "123",
      "author": "A new author",
      "title": "An empty story",
      "content": null,
      "url": "https://aws.amazon.com/appsync/",
      "ups": 1,
      "downs": 0,
      "version": 2
    }
  }
}

Dalam permintaan ini, Anda meminta AWS AppSync dan Amazon DynamoDB untuk memperbarui dan bidang sajatitle. content Semua bidang lainnya dibiarkan sendiri (selain menambah version bidang). Anda mengatur title atribut ke nilai baru dan menghapus content atribut dari posting. Bidang authorurl,ups, dan downs ladang dibiarkan tak tersentuh. Coba jalankan permintaan mutasi lagi sambil meninggalkan permintaan persis apa adanya. Anda akan melihat respons yang mirip dengan berikut ini:

{
  "data": {
    "updatePost": null
  },
  "errors": [
    {
      "path": [
        "updatePost"
      ],
      "data": null,
      "errorType": "DynamoDB:ConditionalCheckFailedException",
      "errorInfo": null,
      "locations": [
        {
          "line": 2,
          "column": 3,
          "sourceName": null
        }
      ],
      "message": "The conditional request failed (Service: DynamoDb, Status Code: 400, Request ID: 1RR3QN5F35CS8IV5VR4OQO9NNBVV4KQNSO5AEMVJF66Q9ASUAAJG)"
    }
  ]
}

Permintaan gagal karena ekspresi kondisi dievaluasi menjadifalse:

  1. Pertama kali Anda menjalankan permintaan, nilai version bidang posting di Amazon DynamoDB 1 adalah, yang cocok dengan argumen. expectedVersion Permintaan berhasil, yang berarti version bidang tersebut bertambah di Amazon DynamoDB ke. 2

  2. Kedua kalinya Anda menjalankan permintaan, nilai version bidang posting di Amazon DynamoDB 2 adalah, yang tidak cocok dengan argumen. expectedVersion

Pola ini biasanya disebut penguncian optimis.

Buat mutasi suara (Amazon DynamoDB UpdateItem)

PostJenis berisi ups dan downs bidang untuk mengaktifkan perekaman upvotes dan downvotes. Namun, pada saat ini, API tidak membiarkan kita melakukan apa pun dengan mereka. Mari tambahkan mutasi untuk memungkinkan kita meningkatkan dan menurunkan suara posting.

Untuk menambahkan mutasi Anda

  1. Di tab AndaAPI, pilih tab Skema.

  2. Di panel Skema, ubah Mutation jenisnya dan tambahkan DIRECTION enum untuk menambahkan mutasi suara baru:

    type Mutation {
    vote(id: ID!, direction: DIRECTION!): Post
    updatePost(
        id: ID!,
        author: String,
        title: String,
        content: String,
        url: String,
        expectedVersion: Int!
    ): Post
    addPost(
        id: ID,
        author: String!,
        title: String!,
        content: String!,
        url: String!
    ): Post!
}

enum DIRECTION {
  UP
  DOWN
}

  3. Pilih Simpan Skema.

  4. Di panel Resolvers di sebelah kanan, temukan vote bidang yang baru dibuat pada Mutation jenisnya, lalu pilih Lampirkan. Buat resolver baru dengan membuat dan mengganti kode dengan cuplikan berikut:

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

export function request(ctx) {
  const field = ctx.args.direction === 'UP' ? 'ups' : 'downs';
  return ddb.update({
    key: { id: ctx.args.id },
    update: {
      [field]: ddb.operations.increment(1),
      version: ddb.operations.increment(1),
    },
  });
}

export const response = (ctx) => ctx.result;

  5. Simpan semua perubahan yang Anda buat.

Panggil API untuk upvote atau downvote sebuah posting

Sekarang resolver baru telah disiapkan, AWS AppSync tahu cara menerjemahkan masuk upvotePost atau downvote mutasi ke operasi Amazon DynamoDB. UpdateItem Anda sekarang dapat menjalankan mutasi untuk upvote atau downvote posting yang Anda buat sebelumnya.

Untuk menjalankan mutasi Anda

  1. Di tab AndaAPI, pilih tab Kueri.

  2. Di panel Kueri, tambahkan mutasi berikut. Anda juga perlu memperbarui id argumen ke nilai yang Anda catat sebelumnya:

    mutation votePost {
  vote(id:123, direction: UP) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

  3. Pilih Run (tombol putar oranye), lalu pilihvotePost.

  4. Posting yang diperbarui di Amazon DynamoDB akan muncul di panel Hasil di sebelah kanan panel Kueri. Itu terlihat serupa dengan yang berikut ini:

    {
  "data": {
    "vote": {
      "id": "123",
      "author": "A new author",
      "title": "An empty story",
      "content": null,
      "url": "https://aws.amazon.com/appsync/",
      "ups": 6,
      "downs": 0,
      "version": 4
    }
  }
}

  5. Pilih Jalankan beberapa kali lagi. Anda akan melihat version bidang ups dan bertambah 1 setiap kali Anda menjalankan kueri.

  6. Ubah kueri untuk menyebutnya dengan yang berbedaDIRECTION.

    mutation votePost {
  vote(id:123, direction: DOWN) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

  7. Pilih Run (tombol putar oranye), lalu pilihvotePost.

    Kali ini, Anda akan melihat version bidang downs dan bertambah 1 setiap kali Anda menjalankan kueri.

Menyiapkan deletePost resolver (Amazon DynamoDB) DeleteItem

Selanjutnya, Anda akan ingin membuat mutasi untuk menghapus posting. Anda akan melakukan ini menggunakan operasi DeleteItem Amazon DynamoDB.

Untuk menambahkan mutasi Anda

  1. Dalam skema Anda, pilih tab Skema.

  2. Di panel Skema, ubah Mutation tipe untuk menambahkan mutasi barudeletePost:

    type Mutation {
    deletePost(id: ID!, expectedVersion: Int): Post
    vote(id: ID!, direction: DIRECTION!): Post
    updatePost(
        id: ID!,
        author: String,
        title: String,
        content: String,
        url: String,
        expectedVersion: Int!
    ): Post
    addPost(
        id: ID
        author: String!,
        title: String!,
        content: String!,
        url: String!
    ): Post!
}

  3. Kali ini, Anda membuat expectedVersion bidang opsional. Selanjutnya, pilih Simpan Skema.

  4. Di panel Resolvers di sebelah kanan, temukan delete bidang yang baru dibuat dalam Mutation tipe, lalu pilih Lampirkan. Buat resolver baru menggunakan kode berikut:

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

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

export function request(ctx) {
  let condition = null;
  if (ctx.args.expectedVersion) {
    condition = {
      or: [
        { id: { attributeExists: false } },
        { version: { eq: ctx.args.expectedVersion } },
      ],
    };
  }
  return ddb.remove({ key: { id: ctx.args.id }, condition });
}

export function response(ctx) {
  const { error, result } = ctx;
  if (error) {
    util.appendError(error.message, error.type);
  }
  return result;
}
    catatan

    expectedVersionArgumen adalah argumen opsional. Jika pemanggil menetapkan expectedVersion argumen dalam permintaan, penangan permintaan menambahkan kondisi yang hanya memungkinkan DeleteItem permintaan berhasil jika item sudah dihapus atau jika version atribut posting di Amazon DynamoDB sama persis dengan. expectedVersion Jika ditinggalkan, tidak ada ekspresi kondisi yang ditentukan pada DeleteItem permintaan. Itu berhasil terlepas dari nilai version atau apakah item tersebut ada di Amazon DynamoDB.

    Meskipun Anda menghapus item, Anda dapat mengembalikan item yang telah dihapus, jika belum dihapus.

Untuk info lebih lanjut tentang DeleteItem permintaan, lihat DeleteItemdokumentasi.

Panggil API untuk menghapus posting

Sekarang resolver telah diatur, AWS AppSync tahu cara menerjemahkan delete mutasi yang masuk ke operasi Amazon DynamoDB. DeleteItem Anda sekarang dapat menjalankan mutasi untuk menghapus sesuatu di tabel.

Untuk menjalankan mutasi Anda

  1. Di tab AndaAPI, pilih tab Kueri.

  2. Di panel Kueri, tambahkan mutasi berikut. Anda juga perlu memperbarui id argumen ke nilai yang Anda catat sebelumnya:

    mutation deletePost {
  deletePost(id:123) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

  3. Pilih Run (tombol putar oranye), lalu pilihdeletePost.

  4. Posting dihapus dari Amazon DynamoDB. Perhatikan bahwa AWS AppSync mengembalikan nilai item yang telah dihapus dari Amazon DynamoDB, yang akan muncul di panel Hasil di sebelah kanan panel Kueri. Itu terlihat serupa dengan yang berikut ini:

    {
  "data": {
    "deletePost": {
      "id": "123",
      "author": "A new author",
      "title": "An empty story",
      "content": null,
      "url": "https://aws.amazon.com/appsync/",
      "ups": 6,
      "downs": 4,
      "version": 12
    }
  }
}

  5. Nilai hanya dikembalikan jika panggilan ini deletePost adalah salah satu yang benar-benar menghapusnya dari Amazon DynamoDB. Pilih Jalankan lagi.

  6. Panggilan masih berhasil, tetapi tidak ada nilai yang dikembalikan:

    {
  "data": {
    "deletePost": null
  }
}

  7. Sekarang, mari kita coba menghapus posting, tapi kali ini menentukan. expectedValue Pertama, Anda harus membuat posting baru karena Anda baru saja menghapus yang telah Anda kerjakan sejauh ini.

  8. Di panel Kueri, tambahkan mutasi berikut:

    mutation addPost {
  addPost(
    id:123
    author: "AUTHORNAME"
    title: "Our second post!"
    content: "A new post."
    url: "https://aws.amazon.com/appsync/"
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

  9. Pilih Run (tombol putar oranye), lalu pilihaddPost.

  10. Hasil posting yang baru dibuat akan muncul di panel Hasil di sebelah kanan panel Kueri. Rekam id objek yang baru dibuat karena Anda akan membutuhkannya hanya dalam beberapa saat. Itu terlihat serupa dengan yang berikut ini:

    {
  "data": {
    "addPost": {
      "id": "123",
      "author": "AUTHORNAME",
      "title": "Our second post!",
      "content": "A new post.",
      "url": "https://aws.amazon.com/appsync/",
      "ups": 1,
      "downs": 0,
      "version": 1
    }
  }
}

  11. Sekarang, mari kita coba menghapus posting itu dengan nilai ilegal untuk expectedVersion. Di panel Kueri, tambahkan mutasi berikut. Anda juga perlu memperbarui id argumen ke nilai yang Anda catat sebelumnya:

    mutation deletePost {
  deletePost(
    id:123
    expectedVersion: 9999
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

  12. Pilih Run (tombol putar oranye), lalu pilihdeletePost. Hasil berikut dikembalikan:

    {
  "data": {
    "deletePost": null
  },
  "errors": [
    {
      "path": [
        "deletePost"
      ],
      "data": null,
      "errorType": "DynamoDB:ConditionalCheckFailedException",
      "errorInfo": null,
      "locations": [
        {
          "line": 2,
          "column": 3,
          "sourceName": null
        }
      ],
      "message": "The conditional request failed (Service: DynamoDb, Status Code: 400, Request ID: 7083O037M1FTFRK038A4CI9H43VV4KQNSO5AEMVJF66Q9ASUAAJG)"
    }
  ]
}

  13. Permintaan gagal karena ekspresi kondisi dievaluasi. false Nilai untuk version posting di Amazon DynamoDB tidak cocok dengan yang ditentukan expectedValue dalam argumen. Nilai objek saat ini dikembalikan di data bidang di errors bagian respons GraphQL. Coba lagi permintaan, tetapi perbaiki: expectedVersion 

    mutation deletePost {
  deletePost(
    id:123
    expectedVersion: 1
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

  14. Pilih Run (tombol putar oranye), lalu pilihdeletePost.

    Kali ini permintaan berhasil, dan nilai yang dihapus dari Amazon DynamoDB dikembalikan:

    {
  "data": {
    "deletePost": {
      "id": "123",
      "author": "AUTHORNAME",
      "title": "Our second post!",
      "content": "A new post.",
      "url": "https://aws.amazon.com/appsync/",
      "ups": 1,
      "downs": 0,
      "version": 1
    }
  }
}

  15. Pilih Jalankan lagi. Panggilan masih berhasil, tetapi kali ini tidak ada nilai yang dikembalikan karena posting sudah dihapus di Amazon DynamoDB.

    { "data": { "deletePost": null } }

Menyiapkan allPost resolver (Amazon DynamoDB Scan)

Sejauh ini, hanya berguna jika Anda mengetahui setiap posting yang ingin Anda lihat. API id Mari tambahkan resolver baru yang mengembalikan semua posting dalam tabel.

Untuk menambahkan mutasi Anda

  1. Di tab AndaAPI, pilih tab Skema.

  2. Di panel Skema, ubah Query jenis untuk menambahkan allPost kueri baru sebagai berikut:

    type Query {
    allPost(limit: Int, nextToken: String): PaginatedPosts!
    getPost(id: ID): Post
}

  3. Tambahkan PaginationPosts tipe baru:

    type PaginatedPosts {
    posts: [Post!]!
    nextToken: String
}

  4. Pilih Simpan Skema.

  5. Di panel Resolvers di sebelah kanan, temukan allPost bidang yang baru dibuat dalam Query tipe, lalu pilih Lampirkan. Buat resolver baru dengan kode berikut:

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

export function request(ctx) {
  const { limit = 20, nextToken } = ctx.arguments;
  return ddb.scan({ limit, nextToken });
}

export function response(ctx) {
  const { items: posts = [], nextToken } = ctx.result;
  return { posts, nextToken };
}

    Handler permintaan resolver ini mengharapkan dua argumen opsional:

    • limit- Menentukan jumlah maksimum item untuk kembali dalam satu panggilan.

    • nextToken- Digunakan untuk mengambil set hasil berikutnya (kami akan menunjukkan dari mana nilai untuk nextToken berasal nanti).

  6. Simpan perubahan apa pun yang dilakukan pada resolver Anda.

Untuk informasi selengkapnya tentang Scan permintaan, lihat dokumentasi referensi Pindai.

Hubungi API untuk memindai semua posting

Sekarang resolver telah diatur, AWS AppSync tahu cara menerjemahkan allPost kueri masuk ke operasi Amazon DynamoDB. Scan Anda sekarang dapat memindai tabel untuk mengambil semua posting. Sebelum Anda dapat mencobanya, Anda perlu mengisi tabel dengan beberapa data karena Anda telah menghapus semua yang telah Anda kerjakan sejauh ini.

Untuk menambah dan menanyakan data

  1. Di tab AndaAPI, pilih tab Kueri.

  2. Di panel Kueri, tambahkan mutasi berikut:

    mutation addPost {
  post1: addPost(id:1 author: "AUTHORNAME" title: "A series of posts, Volume 1" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post2: addPost(id:2 author: "AUTHORNAME" title: "A series of posts, Volume 2" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post3: addPost(id:3 author: "AUTHORNAME" title: "A series of posts, Volume 3" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post4: addPost(id:4 author: "AUTHORNAME" title: "A series of posts, Volume 4" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post5: addPost(id:5 author: "AUTHORNAME" title: "A series of posts, Volume 5" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post6: addPost(id:6 author: "AUTHORNAME" title: "A series of posts, Volume 6" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post7: addPost(id:7 author: "AUTHORNAME" title: "A series of posts, Volume 7" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post8: addPost(id:8 author: "AUTHORNAME" title: "A series of posts, Volume 8" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post9: addPost(id:9 author: "AUTHORNAME" title: "A series of posts, Volume 9" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
}

  3. Pilih Run (tombol putar oranye).

  4. Sekarang, mari kita pindai tabel, mengembalikan lima hasil sekaligus. Di panel Kueri, tambahkan kueri berikut:

    query allPost {
  allPost(limit: 5) {
    posts {
      id
      title
    }
    nextToken
  }
}

  5. Pilih Run (tombol putar oranye), lalu pilihallPost.

    Lima posting pertama akan muncul di panel Hasil di sebelah kanan panel Kueri. Itu terlihat serupa dengan yang berikut ini:

    {
  "data": {
    "allPost": {
      "posts": [
        {
          "id": "5",
          "title": "A series of posts, Volume 5"
        },
        {
          "id": "1",
          "title": "A series of posts, Volume 1"
        },
        {
          "id": "6",
          "title": "A series of posts, Volume 6"
        },
        {
          "id": "9",
          "title": "A series of posts, Volume 9"
        },
        {
          "id": "7",
          "title": "A series of posts, Volume 7"
        }
      ],
      "nextToken": "<token>"
    }
  }
}

  6. Anda menerima lima hasil dan nextToken yang dapat Anda gunakan untuk mendapatkan set hasil berikutnya. Perbarui allPost kueri untuk menyertakan nextToken dari kumpulan hasil sebelumnya: 

    query allPost {
  allPost(
    limit: 5
    nextToken: "<token>"
  ) {
    posts {
      id
      author
    }
    nextToken
  }
}

  7. Pilih Run (tombol putar oranye), lalu pilihallPost.

    Empat posting yang tersisa akan muncul di panel Hasil di sebelah kanan panel Kueri. Tidak ada nextToken dalam rangkaian hasil ini karena Anda telah membaca semua sembilan posting dengan tidak ada yang tersisa. Itu terlihat serupa dengan yang berikut ini:

    {
  "data": {
    "allPost": {
      "posts": [
        {
          "id": "2",
          "title": "A series of posts, Volume 2"
        },
        {
          "id": "3",
          "title": "A series of posts, Volume 3"
        },
        {
          "id": "4",
          "title": "A series of posts, Volume 4"
        },
        {
          "id": "8",
          "title": "A series of posts, Volume 8"
        }
      ],
      "nextToken": null
    }
  }
}

Menyiapkan resolver allPostsBy Penulis (Amazon DynamoDB Query)

Selain memindai Amazon DynamoDB untuk semua posting, Anda juga dapat meminta Amazon DynamoDB untuk mengambil posting yang dibuat oleh penulis tertentu. Tabel Amazon DynamoDB yang Anda buat sebelumnya sudah memiliki panggilan GlobalSecondaryIndex yang author-index dapat Anda gunakan dengan operasi Amazon DynamoDB untuk mengambil semua Query posting yang dibuat oleh penulis tertentu.

Untuk menambahkan kueri Anda

  1. Di tab AndaAPI, pilih tab Skema.

  2. Di panel Skema, ubah Query jenis untuk menambahkan allPostsByAuthor kueri baru sebagai berikut:

    type Query {
    allPostsByAuthor(author: String!, limit: Int, nextToken: String): PaginatedPosts!
    allPost(limit: Int, nextToken: String): PaginatedPosts!
    getPost(id: ID): Post
}

    Perhatikan bahwa ini menggunakan PaginatedPosts jenis yang sama dengan yang Anda gunakan dengan allPost kueri.

  3. Pilih Simpan Skema.

  4. Di panel Resolvers di sebelah kanan, temukan allPostsByAuthor bidang yang baru dibuat pada Query jenisnya, lalu pilih Lampirkan. Buat resolver menggunakan cuplikan di bawah ini:

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

export function request(ctx) {
  const { limit = 20, nextToken, author } = ctx.arguments;
  return ddb.query({
    index: 'author-index',
    query: { author: { eq: author } },
    limit,
    nextToken,
  });
}

export function response(ctx) {
  const { items: posts = [], nextToken } = ctx.result;
  return { posts, nextToken };
}

    Seperti allPost resolver, resolver ini memiliki dua argumen opsional:

    • limit- Menentukan jumlah maksimum item untuk kembali dalam satu panggilan.

    • nextToken- Mengambil set hasil berikutnya (nilai untuk nextToken dapat diperoleh dari panggilan sebelumnya).

  5. Simpan perubahan apa pun yang dilakukan pada resolver Anda.

Untuk informasi selengkapnya tentang Query permintaan, lihat dokumentasi referensi kueri.

Panggil API untuk menanyakan semua posting oleh penulis

Sekarang resolver telah diatur, AWS AppSync tahu bagaimana menerjemahkan allPostsByAuthor mutasi yang masuk ke operasi DynamoDB terhadap indeks. Query author-index Anda sekarang dapat meminta tabel untuk mengambil semua posting oleh penulis tertentu.

Sebelum ini, bagaimanapun, mari kita mengisi tabel dengan beberapa posting lagi, karena setiap posting sejauh ini memiliki penulis yang sama.

Untuk menambahkan data dan kueri

  1. Di tab AndaAPI, pilih tab Kueri.

  2. Di panel Kueri, tambahkan mutasi berikut:

    mutation addPost {
  post1: addPost(id:10 author: "Nadia" title: "The cutest dog in the world" content: "So cute. So very, very cute." url: "https://aws.amazon.com/appsync/" ) { author, title }
  post2: addPost(id:11 author: "Nadia" title: "Did you know...?" content: "AppSync works offline?" url: "https://aws.amazon.com/appsync/" ) { author, title }
  post3: addPost(id:12 author: "Steve" title: "I like GraphQL" content: "It's great" url: "https://aws.amazon.com/appsync/" ) { author, title }
}

  3. Pilih Run (tombol putar oranye), lalu pilihaddPost.

  4. Sekarang, mari kita menanyakan tabel, mengembalikan semua posting yang ditulis oleh. Nadia Di panel Kueri, tambahkan kueri berikut: 

    query allPostsByAuthor {
  allPostsByAuthor(author: "Nadia") {
    posts {
      id
      title
    }
    nextToken
  }
}

  5. Pilih Run (tombol putar oranye), lalu pilihallPostsByAuthor. Semua posting yang ditulis oleh akan Nadia muncul di panel Hasil di sebelah kanan panel Queries. Itu terlihat serupa dengan yang berikut ini:

    {
  "data": {
    "allPostsByAuthor": {
      "posts": [
        {
          "id": "10",
          "title": "The cutest dog in the world"
        },
        {
          "id": "11",
          "title": "Did you know...?"
        }
      ],
      "nextToken": null
    }
  }
}

  6. Pagination bekerja untuk hal yang Query sama seperti yang dilakukannya. Scan Sebagai contoh, mari kita cari semua posting denganAUTHORNAME, mendapatkan lima sekaligus.

  7. Di panel Kueri, tambahkan kueri berikut: 

    query allPostsByAuthor {
  allPostsByAuthor(
    author: "AUTHORNAME"
    limit: 5
  ) {
    posts {
      id
      title
    }
    nextToken
  }
}

  8. Pilih Run (tombol putar oranye), lalu pilihallPostsByAuthor. Semua posting yang ditulis oleh akan AUTHORNAME muncul di panel Hasil di sebelah kanan panel Queries. Itu terlihat serupa dengan yang berikut ini:

    {
  "data": {
    "allPostsByAuthor": {
      "posts": [
        {
          "id": "6",
          "title": "A series of posts, Volume 6"
        },
        {
          "id": "4",
          "title": "A series of posts, Volume 4"
        },
        {
          "id": "2",
          "title": "A series of posts, Volume 2"
        },
        {
          "id": "7",
          "title": "A series of posts, Volume 7"
        },
        {
          "id": "1",
          "title": "A series of posts, Volume 1"
        }
      ],
      "nextToken": "<token>"
    }
  }
}

  9. Perbarui nextToken argumen dengan nilai yang dikembalikan dari kueri sebelumnya sebagai berikut:

    query allPostsByAuthor {
  allPostsByAuthor(
    author: "AUTHORNAME"
    limit: 5
    nextToken: "<token>"
  ) {
    posts {
      id
      title
    }
    nextToken
  }
}

  10. Pilih Run (tombol putar oranye), lalu pilihallPostsByAuthor. Posting yang tersisa yang ditulis oleh AUTHORNAME akan muncul di panel Hasil di sebelah kanan panel Kueri. Itu terlihat serupa dengan yang berikut ini:

    {
  "data": {
    "allPostsByAuthor": {
      "posts": [
        {
          "id": "8",
          "title": "A series of posts, Volume 8"
        },
        {
          "id": "5",
          "title": "A series of posts, Volume 5"
        },
        {
          "id": "3",
          "title": "A series of posts, Volume 3"
        },
        {
          "id": "9",
          "title": "A series of posts, Volume 9"
        }
      ],
      "nextToken": null
    }
  }
}

Menggunakan set

Sampai saat ini, Post tipe telah menjadi objek kunci/nilai datar. Anda juga dapat memodelkan objek kompleks dengan resolver Anda, seperti set, daftar, dan peta. Mari kita perbarui Post jenis untuk menyertakan tag. Sebuah posting dapat memiliki nol atau lebih tag, yang disimpan di DynamoDB sebagai String Set. Anda juga akan menyiapkan beberapa mutasi untuk menambah dan menghapus tag, dan kueri baru untuk memindai posting dengan tag tertentu.

Untuk mengatur data Anda

  1. Di tab AndaAPI, pilih tab Skema.

  2. Di panel Skema, ubah Post jenis untuk menambahkan tags bidang baru sebagai berikut:

    type Post {
  id: ID!
  author: String
  title: String
  content: String
  url: String
  ups: Int!
  downs: Int!
  version: Int!
  tags: [String!]
}

  3. Di panel Skema, ubah Query jenis untuk menambahkan allPostsByTag kueri baru sebagai berikut:

    type Query {
  allPostsByTag(tag: String!, limit: Int, nextToken: String): PaginatedPosts!
  allPostsByAuthor(author: String!, limit: Int, nextToken: String): PaginatedPosts!
  allPost(limit: Int, nextToken: String): PaginatedPosts!
  getPost(id: ID): Post
}

  4. Di panel Skema, ubah Mutation tipe untuk menambahkan baru addTag dan removeTag mutasi sebagai berikut:

    type Mutation {
  addTag(id: ID!, tag: String!): Post
  removeTag(id: ID!, tag: String!): Post
  deletePost(id: ID!, expectedVersion: Int): Post
  upvotePost(id: ID!): Post
  downvotePost(id: ID!): Post
  updatePost(
    id: ID!,
    author: String,
    title: String,
    content: String,
    url: String,
    expectedVersion: Int!
  ): Post
  addPost(
    author: String!,
    title: String!,
    content: String!,
    url: String!
  ): Post!
}

  5. Pilih Simpan Skema.

  6. Di panel Resolvers di sebelah kanan, temukan allPostsByTag bidang yang baru dibuat pada Query jenisnya, lalu pilih Lampirkan. Buat resolver Anda menggunakan cuplikan di bawah ini:

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

export function request(ctx) {
  const { limit = 20, nextToken, tag } = ctx.arguments;
  return ddb.scan({ limit, nextToken, filter: { tags: { contains: tag } } });
}

export function response(ctx) {
  const { items: posts = [], nextToken } = ctx.result;
  return { posts, nextToken };
}

  7. Simpan perubahan apa pun yang telah Anda buat pada resolver Anda.

  8. Sekarang, lakukan hal yang sama untuk Mutation bidang addTag menggunakan cuplikan di bawah ini:

    catatan

    Meskipun utilitas DynamoDB saat ini tidak mendukung operasi set, Anda masih dapat berinteraksi dengan set dengan membuat permintaan sendiri.

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

export function request(ctx) {
	const { id, tag } = ctx.arguments
	const expressionValues = util.dynamodb.toMapValues({ ':plusOne': 1 })
	expressionValues[':tags'] = util.dynamodb.toStringSet([tag])

	return {
		operation: 'UpdateItem',
		key: util.dynamodb.toMapValues({ id }),
		update: {
			expression: `ADD tags :tags, version :plusOne`,
			expressionValues,
		},
	}
}

export const response = (ctx) => ctx.result

  9. Simpan perubahan apa pun yang dilakukan pada resolver Anda.

  10. Ulangi ini sekali lagi untuk Mutation bidang removeTag menggunakan cuplikan di bawah ini:

    import { util } from '@aws-appsync/utils';
	
export function request(ctx) {
	  const { id, tag } = ctx.arguments;
	  const expressionValues = util.dynamodb.toMapValues({ ':plusOne': 1 });
	  expressionValues[':tags'] = util.dynamodb.toStringSet([tag]);
	
	  return {
	    operation: 'UpdateItem',
	    key: util.dynamodb.toMapValues({ id }),
	    update: {
	      expression: `DELETE tags :tags ADD version :plusOne`,
	      expressionValues,
	    },
	  };
	}
	
	export const response = (ctx) => ctx.resultexport

  11. Simpan perubahan apa pun yang dilakukan pada resolver Anda.

Panggil API untuk bekerja dengan tag

Sekarang setelah Anda menyiapkan resolver, AWS AppSync tahu cara menerjemahkan masuk addTagremoveTag, dan permintaan allPostsByTag ke DynamoDB dan operasi. UpdateItem Scan Untuk mencobanya, mari pilih salah satu posting yang Anda buat sebelumnya. Misalnya, mari kita gunakan posting yang ditulis oleh. Nadia

Untuk menggunakan tag

  1. Di tab AndaAPI, pilih tab Kueri.

  2. Di panel Kueri, tambahkan kueri berikut:

    query allPostsByAuthor {
  allPostsByAuthor(
    author: "Nadia"
  ) {
    posts {
      id
      title
    }
    nextToken
  }
}

  3. Pilih Run (tombol putar oranye), lalu pilihallPostsByAuthor.

  4. Semua postingan Nadia akan muncul di panel Hasil di sebelah kanan panel Kueri. Itu terlihat serupa dengan yang berikut ini:

    {
  "data": {
    "allPostsByAuthor": {
      "posts": [
        {
          "id": "10",
          "title": "The cutest dog in the world"
        },
        {
          "id": "11",
          "title": "Did you known...?"
        }
      ],
      "nextToken": null
    }
  }
}

  5. Mari kita gunakan yang memiliki judul The cutest dog in the world. Rekam id karena Anda akan menggunakannya nanti. Sekarang, mari kita coba menambahkan dog tag.

  6. Di panel Kueri, tambahkan mutasi berikut. Anda juga perlu memperbarui id argumen ke nilai yang Anda catat sebelumnya.

    mutation addTag {
  addTag(id:10 tag: "dog") {
    id
    title
    tags
  }
}

  7. Pilih Run (tombol putar oranye), lalu pilihaddTag. Posting diperbarui dengan tag baru:

    {
  "data": {
    "addTag": {
      "id": "10",
      "title": "The cutest dog in the world",
      "tags": [
        "dog"
      ]
    }
  }
}

  8. Anda dapat menambahkan lebih banyak tag. Perbarui mutasi untuk mengubah tag argumen menjadipuppy:

    mutation addTag {
  addTag(id:10 tag: "puppy") {
    id
    title
    tags
  }
}

  9. Pilih Run (tombol putar oranye), lalu pilihaddTag. Posting diperbarui dengan tag baru:

    {
  "data": {
    "addTag": {
      "id": "10",
      "title": "The cutest dog in the world",
      "tags": [
        "dog",
        "puppy"
      ]
    }
  }
}

  10. Anda juga dapat menghapus tag. Di panel Kueri, tambahkan mutasi berikut. Anda juga perlu memperbarui id argumen ke nilai yang Anda catat sebelumnya:

    mutation removeTag {
  removeTag(id:10 tag: "puppy") {
    id
    title
    tags
  }
}

  11. Pilih Run (tombol putar oranye), lalu pilihremoveTag. Posting diperbarui dan puppy tag dihapus.

    {
  "data": {
    "addTag": {
      "id": "10",
      "title": "The cutest dog in the world",
      "tags": [
        "dog"
      ]
    }
  }
}

  12. Anda juga dapat mencari semua posting yang memiliki tag. Di panel Kueri, tambahkan kueri berikut: 

    query allPostsByTag {
  allPostsByTag(tag: "dog") {
    posts {
      id
      title
      tags
    }
    nextToken
  }
}

  13. Pilih Run (tombol putar oranye), lalu pilihallPostsByTag. Semua posting yang memiliki dog tag dikembalikan sebagai berikut:

    {
  "data": {
    "allPostsByTag": {
      "posts": [
        {
          "id": "10",
          "title": "The cutest dog in the world",
          "tags": [
            "dog",
            "puppy"
          ]
        }
      ],
      "nextToken": null
    }
  }
}

Kesimpulan

Dalam tutorial ini, Anda telah membangun sebuah API yang memungkinkan Anda memanipulasi Post objek di AWS AppSync DynamoDB menggunakan dan GraphQL.

Untuk membersihkan, Anda dapat menghapus AWS AppSync API GraphQL dari konsol.

Untuk menghapus peran yang terkait dengan tabel DynamoDB Anda, pilih sumber data Anda di tabel Sumber Data dan klik edit. Perhatikan nilai peran di bawah Buat atau gunakan peran yang ada. Buka IAM konsol untuk menghapus peran.

Untuk menghapus tabel DynamoDB Anda, klik pada nama tabel dalam daftar sumber data. Ini akan membawa Anda ke konsol DynamoDB tempat Anda dapat menghapus tabel.