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

# Menggabungkan resolver GraphQL di AWS AppSync
<a name="tutorial-combining-graphql-resolvers-js"></a>

Resolver dan bidang dalam skema GraphQL memiliki hubungan 1:1 dengan tingkat fleksibilitas yang besar. Karena sumber data dikonfigurasi pada resolver secara independen dari skema, Anda memiliki kemampuan untuk menyelesaikan atau memanipulasi tipe GraphQL Anda melalui sumber data yang berbeda, memungkinkan Anda untuk mencampur dan mencocokkan skema untuk memenuhi kebutuhan Anda.

Skenario berikut menunjukkan cara mencampur dan mencocokkan sumber data dalam skema Anda. Sebelum memulai, Anda harus terbiasa dengan mengonfigurasi sumber data dan resolver untuk, Amazon AWS Lambda DynamoDB, dan Amazon Service. OpenSearch 

## Contoh skema
<a name="example-schema-js"></a>

Skema berikut memiliki jenis `Post` dengan tiga `Query` dan `Mutation` operasi masing-masing:

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

type Query {
    allPost: [Post]
    getPost(id: ID!): Post
    searchPosts: [Post]
}

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

Dalam contoh ini, Anda akan memiliki total enam resolver dengan masing-masing membutuhkan sumber data. Salah satu cara untuk mengatasi masalah ini adalah dengan menghubungkannya ke satu tabel Amazon DynamoDB, yang `Posts` disebut, di mana `AllPost` bidang menjalankan pemindaian dan `searchPosts` bidang menjalankan kueri ([JavaScriptlihat referensi fungsi resolver](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html) untuk DynamoDB). Namun, Anda tidak terbatas pada Amazon DynamoDB; sumber data yang berbeda seperti Lambda OpenSearch atau Layanan ada untuk memenuhi persyaratan bisnis Anda. 

## Mengubah data melalui resolver
<a name="alter-data-through-resolvers-js"></a>

Anda mungkin perlu mengembalikan hasil dari database pihak ketiga yang tidak didukung secara langsung oleh sumber AWS AppSync data. Anda mungkin juga harus melakukan modifikasi kompleks pada data sebelum dikembalikan ke klien API. Hal ini dapat disebabkan oleh pemformatan tipe data yang tidak tepat, seperti perbedaan stempel waktu pada klien, atau penanganan masalah kompatibilitas mundur. Dalam hal ini, menghubungkan AWS Lambda fungsi sebagai sumber data ke AWS AppSync API Anda adalah solusi yang tepat. Untuk tujuan ilustrasi, dalam contoh berikut, AWS Lambda fungsi memanipulasi data yang diambil dari penyimpanan data pihak ketiga:

```
export const handler = (event, context, callback) => {
    // fetch data
    const result = fetcher()

    // apply complex business logic
    const data = transform(result)	

    // return to AppSync
    return data
};
```

Ini adalah fungsi Lambda yang benar-benar valid dan dapat dilampirkan ke `AllPost` bidang dalam skema GraphQL sehingga setiap kueri yang mengembalikan semua hasil mendapat angka acak untuk naik/turun.

## DynamoDB dan Layanan OpenSearch
<a name="ddb-and-es-js"></a>

Untuk beberapa aplikasi, Anda mungkin melakukan mutasi atau kueri pencarian sederhana terhadap DynamoDB dan memiliki proses latar belakang mentransfer dokumen ke Layanan. OpenSearch Anda cukup melampirkan `searchPosts` resolver ke sumber data OpenSearch Layanan dan mengembalikan hasil pencarian (dari data yang berasal dari DynamoDB) menggunakan kueri GraphQL. Ini bisa sangat kuat saat menambahkan operasi pencarian lanjutan ke aplikasi Anda seperti kata kunci, kecocokan kata kabur, atau bahkan pencarian geospasial. Mentransfer data dari DynamoDB dapat dilakukan melalui proses ETL, atau sebagai alternatif, Anda dapat melakukan streaming dari DynamoDB menggunakan Lambda.

Untuk memulai dengan sumber data khusus ini, lihat tutorial [DynamoDB](https://docs.aws.amazon.com/appsync/latest/devguide/tutorial-dynamodb-resolvers-js.html) [dan](https://docs.aws.amazon.com/appsync/latest/devguide/tutorial-lambda-resolvers-js.html) Lambda kami.

Misalnya, menggunakan skema dari tutorial kami sebelumnya, mutasi berikut menambahkan item ke DynamoDB:

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

Ini menulis data ke DynamoDB, yang kemudian mengalirkan data melalui Lambda ke OpenSearch Amazon Service, yang kemudian Anda gunakan untuk mencari posting berdasarkan bidang yang berbeda. Misalnya, karena data ada di OpenSearch Layanan Amazon, Anda dapat mencari bidang penulis atau konten dengan teks bentuk bebas, bahkan dengan spasi, sebagai berikut:

```
query searchName{
    searchAuthor(name:"   Nadia   "){
        id
        title
        content
    }
}

---------- or ----------

query searchContent{
    searchContent(text:"test"){
        id
        title
        content
    }
}
```

Karena data ditulis langsung ke DynamoDB, Anda masih dapat melakukan operasi pencarian daftar atau item yang efisien terhadap tabel dengan dan kueri. `allPost{...}` `getPost{...}` Tumpukan ini menggunakan kode contoh berikut untuk aliran DynamoDB:

**catatan**  
Kode Python ini adalah contoh dan tidak dimaksudkan untuk digunakan dalam kode produksi.

```
import boto3
import requests
from requests_aws4auth import AWS4Auth

region = '' # e.g. us-east-1
service = 'es'
credentials = boto3.Session().get_credentials()
awsauth = AWS4Auth(credentials.access_key, credentials.secret_key, region, service, session_token=credentials.token)

host = '' # the OpenSearch Service domain, e.g. https://search-mydomain.us-west-1.es.amazonaws.com
index = 'lambda-index'
datatype = '_doc'
url = host + '/' + index + '/' + datatype + '/'

headers = { "Content-Type": "application/json" }

def handler(event, context):
    count = 0
    for record in event['Records']:
        # Get the primary key for use as the OpenSearch ID
        id = record['dynamodb']['Keys']['id']['S']

        if record['eventName'] == 'REMOVE':
            r = requests.delete(url + id, auth=awsauth)
        else:
            document = record['dynamodb']['NewImage']
            r = requests.put(url + id, auth=awsauth, json=document, headers=headers)
        count += 1
    return str(count) + ' records processed.'
```

Anda kemudian dapat menggunakan aliran DynamoDB untuk melampirkan ini ke tabel DynamoDB dengan kunci `id` utama, dan setiap perubahan pada sumber DynamoDB akan mengalir ke domain Layanan Anda. OpenSearch Untuk informasi selengkapnya tentang mengonfigurasi ini, lihat dokumentasi [DynamoDB Streams](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.Lambda.html).