Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Membuat query dasar () JavaScript
GraphQL resolver menghubungkan bidang dalam skema tipe ke sumber data. Resolver adalah mekanisme dimana permintaan dipenuhi.
Resolver AWS AppSync digunakan JavaScript untuk mengonversi ekspresi GraphQL menjadi format yang dapat digunakan sumber data. Atau, template pemetaan dapat ditulis dalam [Apache Velocity Template Language (VTL) untuk](https://velocity.apache.org/engine/2.0/vtl-reference.html) mengubah ekspresi GraphQL menjadi format yang dapat digunakan sumber data.
Bagian ini menjelaskan cara mengkonfigurasi resolver menggunakan. JavaScript Bagian tutorial [Resolver (JavaScript) menyediakan tutorial](https://docs.aws.amazon.com/appsync/latest/devguide/tutorials-js.html) mendalam tentang cara menerapkan resolver menggunakan. JavaScript Bagian [Referensi Resolver (JavaScript)](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html) memberikan penjelasan tentang operasi utilitas yang dapat digunakan dengan JavaScript resolver.
Sebaiknya ikuti panduan ini sebelum mencoba menggunakan salah satu tutorial yang disebutkan di atas.
Di bagian ini, kita akan membahas cara membuat dan mengkonfigurasi resolver untuk kueri dan mutasi.
**catatan**
Panduan ini mengasumsikan Anda telah membuat skema Anda dan memiliki setidaknya satu kueri atau mutasi. Jika Anda mencari langganan (data waktu nyata), lihat panduan [ini](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-real-time-data.html).
Di bagian ini, kami akan memberikan beberapa langkah umum untuk mengonfigurasi resolver bersama dengan contoh yang menggunakan skema di bawah ini:
```
// schema.graphql file
input CreatePostInput {
title: String
date: AWSDateTime
}
type Post {
id: ID!
title: String
date: AWSDateTime
}
type Mutation {
createPost(input: CreatePostInput!): Post
}
type Query {
getPost: [Post]
}
```
## Membuat resolver kueri dasar
Bagian ini akan menunjukkan cara membuat resolver kueri dasar.
------
#### [ Console ]
1. Masuk ke Konsol Manajemen AWS dan buka [AppSynckonsol](https://console.aws.amazon.com/appsync/).
1. Di **APIs dasbor**, pilih GraphQL API Anda.
1. Di **Sidebar**, pilih **Skema**.
1. Masukkan detail skema dan sumber data Anda. Lihat bagian [Merancang skema Anda](https://docs.aws.amazon.com/appsync/latest/devguide/designing-your-schema.html) dan [Melampirkan sumber data](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html) untuk informasi selengkapnya.
1. Di sebelah editor **Skema**, Ada jendela bernama **Resolvers**. Kotak ini berisi daftar jenis dan bidang seperti yang didefinisikan di jendela **Skema** Anda. Anda dapat melampirkan resolver ke bidang. Anda kemungkinan besar akan melampirkan resolver ke operasi lapangan Anda. Pada bagian ini, kita akan melihat konfigurasi query sederhana. Di bawah Jenis **kueri**, pilih **Lampirkan** di sebelah bidang kueri Anda.
1. Pada halaman **Attach resolver**, di bawah **jenis Resolver, Anda dapat memilih antara pipeline atau resolver** unit. Untuk informasi selengkapnya tentang jenis ini, lihat [Resolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-components.html). Panduan ini akan memanfaatkan`pipeline resolvers`.
**Tip**
Saat membuat resolver pipeline, sumber data Anda akan dilampirkan ke fungsi pipeline. Fungsi dibuat setelah Anda membuat resolver pipeline itu sendiri, itulah sebabnya tidak ada opsi untuk mengaturnya di halaman ini. Jika Anda menggunakan resolver unit, sumber data terikat langsung ke resolver, jadi Anda akan mengaturnya di halaman ini.
Untuk **runtime Resolver, pilih `APPSYNC_JS` untuk mengaktifkan runtime**. JavaScript
1. Anda dapat mengaktifkan [caching](https://docs.aws.amazon.com/appsync/latest/devguide/enabling-caching.html) untuk API ini. Sebaiknya matikan fitur ini untuk saat ini. Pilih **Buat**.
1. Pada halaman **Edit resolver**, ada editor kode bernama kode **Resolver** yang memungkinkan Anda mengimplementasikan logika untuk penangan dan respons resolver (sebelum dan sesudah langkah). Untuk informasi selengkapnya, lihat ikhtisar [JavaScriptresolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html).
**catatan**
Dalam contoh kita, kita hanya akan membiarkan permintaan kosong dan respons ditetapkan untuk mengembalikan hasil sumber data terakhir dari [konteks](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html):
```
import {util} from '@aws-appsync/utils';
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
```
Di bawah bagian ini, ada tabel yang disebut **Functions**. Fungsi memungkinkan Anda untuk menerapkan kode yang dapat digunakan kembali di beberapa resolver. Alih-alih terus-menerus menulis ulang atau menyalin kode, Anda dapat menyimpan kode sumber sebagai fungsi untuk ditambahkan ke resolver kapan pun Anda membutuhkannya.
Fungsi membentuk sebagian besar daftar operasi pipa. Saat menggunakan beberapa fungsi dalam resolver, Anda mengatur urutan fungsi, dan mereka akan dijalankan dalam urutan itu secara berurutan. Mereka dieksekusi setelah fungsi permintaan berjalan dan sebelum fungsi respon dimulai.
Untuk menambahkan fungsi baru, di bawah **Fungsi**, pilih **Tambah fungsi**, lalu **Buat fungsi baru**. Atau, Anda mungkin melihat tombol **Create function** untuk memilih sebagai gantinya.
1. Pilih sumber data. Ini akan menjadi sumber data tempat resolver bertindak.
**catatan**
Dalam contoh kita, kita melampirkan resolver untuk`getPost`, yang mengambil objek oleh. `Post` `id` Mari kita asumsikan kita sudah menyiapkan tabel DynamoDB untuk skema ini. Kunci partisi diatur ke `id` dan kosong.
1. Masukkan a`Function name`.
1. Di bawah **kode Fungsi**, Anda harus mengimplementasikan perilaku fungsi. Ini mungkin membingungkan, tetapi setiap fungsi akan memiliki permintaan lokal dan penangan respons sendiri. Permintaan berjalan, kemudian pemanggilan sumber data dibuat untuk menangani permintaan, kemudian respons sumber data diproses oleh penangan respons. Hasilnya disimpan dalam objek [konteks](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html). Setelah itu, fungsi berikutnya dalam daftar akan berjalan atau akan diteruskan ke penangan respons langkah setelah jika itu yang terakhir.
**catatan**
Dalam contoh kita, kita melampirkan resolver ke`getPost`, yang mendapat daftar `Post` objek dari sumber data. Fungsi permintaan kami akan meminta data dari tabel kami, tabel akan meneruskan responsnya ke konteks (ctx), maka respons akan mengembalikan hasilnya dalam konteks. AWS AppSync Kekuatan terletak pada keterkaitannya dengan layanan lain. AWS Karena kami menggunakan DynamoDB, kami memiliki [serangkaian operasi untuk menyederhanakan hal-hal](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html) seperti ini. Kami memiliki beberapa contoh boilerplate untuk tipe sumber data lainnya juga.
Kode kita akan terlihat seperti ini:
```
import { util } from '@aws-appsync/utils';
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
return { operation: 'Scan' };
}
/**
* return a list of scanned post items
*/
export function response(ctx) {
return ctx.result.items;
}
```
Pada langkah ini, kami menambahkan dua fungsi:
`request`: Handler permintaan melakukan operasi pengambilan terhadap sumber data. Argumen berisi objek konteks (`ctx`), atau beberapa data yang tersedia untuk semua resolver melakukan operasi tertentu. Misalnya, mungkin berisi data otorisasi, nama bidang yang diselesaikan, dll. Pernyataan pengembalian melakukan [https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan](https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan)operasi (lihat [di sini](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html) untuk contoh). Karena kami bekerja dengan DynamoDB, kami diizinkan untuk menggunakan beberapa operasi dari layanan itu. Pemindaian melakukan pengambilan dasar semua item di tabel kami. Hasil operasi ini disimpan dalam objek konteks sebagai `result` wadah sebelum diteruskan ke handler respons. `request`Dijalankan sebelum respons dalam pipa.
`response`: Response handler yang mengembalikan output dari. `request` Argumennya adalah objek konteks yang diperbarui, dan pernyataan pengembaliannya adalah`ctx.prev.result`. Pada titik ini dalam panduan ini, Anda mungkin tidak terbiasa dengan nilai ini. `ctx`mengacu pada objek konteks. `prev`mengacu pada operasi sebelumnya dalam pipa, yang merupakan milik kami`request`. `result`Berisi hasil resolver saat bergerak melalui pipa. Jika Anda menempatkan semuanya bersama-sama, `ctx.prev.result` mengembalikan hasil dari operasi terakhir yang dilakukan, yang merupakan handler permintaan.
1. Pilih **Buat** setelah selesai.
1. Kembali ke layar resolver, di bawah **Fungsi**, pilih drop-down **Tambah fungsi** dan tambahkan fungsi Anda ke daftar fungsi Anda.
1. Pilih **Simpan** untuk memperbarui resolver.
------
#### [ CLI ]
**Untuk menambahkan fungsi Anda**
+ Buat fungsi untuk resolver pipeline Anda menggunakan perintah. `[create-function](https://docs.aws.amazon.com/cli/latest/reference/appsync/create-function.html)`
Anda harus memasukkan beberapa parameter untuk perintah khusus ini:
1. API Anda. `api-id`
1. `name`Fungsi di AWS AppSync konsol.
1. Itu`data-source-name`, atau nama sumber data yang akan digunakan fungsi. Itu harus sudah dibuat dan ditautkan ke GraphQL API Anda di layanan. AWS AppSync
1. atau lingkungan dan bahasa dari fungsi tersebut. `runtime` Untuk JavaScript, nama harus`APPSYNC_JS`, dan runtime,`1.0.0`.
1. Penangan`code`, atau permintaan dan respons fungsi Anda. Meskipun Anda dapat mengetiknya secara manual, jauh lebih mudah untuk menambahkannya ke file.txt (atau format serupa) dan kemudian meneruskannya sebagai argumen.
**catatan**
Kode kueri kami akan berada dalam file yang diteruskan sebagai argumen:
```
import { util } from '@aws-appsync/utils';
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
return { operation: 'Scan' };
}
/**
* return a list of scanned post items
*/
export function response(ctx) {
return ctx.result.items;
}
```
Contoh perintah mungkin terlihat seperti ini:
```
aws appsync create-function \
--api-id abcdefghijklmnopqrstuvwxyz \
--name get_posts_func_1 \
--data-source-name table-for-posts \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file://~/path/to/file/{filename}.{fileType}
```
Output akan dikembalikan dalam CLI. Inilah contohnya:
```
{
"functionConfiguration": {
"functionId": "ejglgvmcabdn7lx75ref4qeig4",
"functionArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/functions/ejglgvmcabdn7lx75ref4qeig4",
"name": "get_posts_func_1",
"dataSourceName": "table-for-posts",
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
**catatan**
Pastikan Anda merekam `functionId` suatu tempat karena ini akan digunakan untuk melampirkan fungsi ke resolver.
**Untuk membuat resolver Anda**
+ Buat fungsi pipeline `Query` dengan menjalankan `[create-resolver](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)` perintah.
Anda harus memasukkan beberapa parameter untuk perintah khusus ini:
1. API Anda. `api-id`
1. Jenis objek`type-name`, atau khusus dalam skema Anda (Query, Mutation, Subscription).
1. Operasi`field-name`, atau bidang di dalam jenis objek khusus yang ingin Anda lampirkan resolver.
1. The`kind`, yang menentukan unit atau resolver pipa. Setel ini `PIPELINE` untuk mengaktifkan fungsi pipeline.
1. The`pipeline-config`, atau fungsi (s) untuk melampirkan ke resolver. Pastikan Anda mengetahui `functionId` nilai-nilai fungsi Anda. Urutan daftar penting.
1. Yang`runtime`, yang `APPSYNC_JS` (JavaScript). `runtimeVersion`Saat ini adalah`1.0.0`.
1. Itu`code`, yang berisi penangan langkah sebelum dan sesudah.
**catatan**
Kode kueri kami akan berada dalam file yang diteruskan sebagai argumen:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
const { id, ...values } = ctx.args;
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id }),
attributeValues: util.dynamodb.toMapValues(values),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Contoh perintah mungkin terlihat seperti ini:
```
aws appsync create-resolver \
--api-id abcdefghijklmnopqrstuvwxyz \
--type-name Query \
--field-name getPost \
--kind PIPELINE \
--pipeline-config functions=ejglgvmcabdn7lx75ref4qeig4 \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
Output akan dikembalikan dalam CLI. Inilah contohnya:
```
{
"resolver": {
"typeName": "Mutation",
"fieldName": "getPost",
"resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Mutation/resolvers/getPost",
"kind": "PIPELINE",
"pipelineConfig": {
"functions": [
"ejglgvmcabdn7lx75ref4qeig4"
]
},
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
------
#### [ CDK ]
**Tip**
[Sebelum Anda menggunakan CDK, kami sarankan untuk meninjau [dokumentasi resmi](https://docs.aws.amazon.com/cdk/v2/guide/home.html) CDK bersama dengan referensi CDK AWS AppSync.](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html)
Langkah-langkah yang tercantum di bawah ini hanya akan menampilkan contoh umum dari cuplikan yang digunakan untuk menambahkan sumber daya tertentu. Ini **tidak** dimaksudkan untuk menjadi solusi yang berfungsi dalam kode produksi Anda. Kami juga menganggap Anda sudah memiliki aplikasi yang berfungsi.
Aplikasi dasar akan membutuhkan hal-hal berikut:
1. Arahan impor layanan
1. Kode skema
1. Generator sumber data
1. Kode fungsi
1. Kode penyelesai
Dari bagian [Merancang skema Anda](https://docs.aws.amazon.com/appsync/latest/devguide/designing-your-schema.html) dan [Melampirkan sumber data](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html), kami tahu bahwa file tumpukan akan menyertakan arahan impor formulir:
```
import * as x from 'x'; # import wildcard as the 'x' keyword from 'x-service'
import {a, b, ...} from 'c'; # import {specific constructs} from 'c-service'
```
**catatan**
Di bagian sebelumnya, kami hanya menyatakan cara AWS AppSync mengimpor konstruksi. Dalam kode nyata, Anda harus mengimpor lebih banyak layanan hanya untuk menjalankan aplikasi. Dalam contoh kami, jika kami membuat aplikasi CDK yang sangat sederhana, kami setidaknya akan mengimpor AWS AppSync layanan bersama dengan sumber data kami, yang merupakan tabel DynamoDB. Kami juga perlu mengimpor beberapa konstruksi tambahan untuk menerapkan aplikasi:
```
import * as cdk from 'aws-cdk-lib';
import * as appsync from 'aws-cdk-lib/aws-appsync';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
import { Construct } from 'constructs';
```
Untuk meringkas masing-masing:
`import * as cdk from 'aws-cdk-lib';`: Ini memungkinkan Anda untuk menentukan aplikasi CDK dan konstruksi seperti tumpukan. Ini juga berisi beberapa fungsi utilitas yang berguna untuk aplikasi kita seperti memanipulasi metadata. Jika Anda terbiasa dengan arahan impor ini, tetapi bertanya-tanya mengapa pustaka inti cdk tidak digunakan di sini, lihat halaman [Migrasi](https://docs.aws.amazon.com/cdk/v2/guide/migrating-v2.html).
`import * as appsync from 'aws-cdk-lib/aws-appsync';`: Ini mengimpor [AWS AppSync layanan](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html).
`import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';`: Ini mengimpor layanan [DynamoDB](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb-readme.html).
`import { Construct } from 'constructs';`: Kita membutuhkan ini untuk mendefinisikan [konstruksi](https://docs.aws.amazon.com/cdk/v2/guide/constructs.html) root.
Jenis impor tergantung pada layanan yang Anda panggil. Kami merekomendasikan untuk melihat dokumentasi CDK sebagai contoh. Skema di bagian atas halaman akan menjadi file terpisah di aplikasi CDK Anda sebagai `.graphql` file. Dalam file stack, kita dapat mengaitkannya dengan GraphQL baru menggunakan formulir:
```
const add_api = new appsync.GraphqlApi(this, 'graphQL-example', {
name: 'my-first-api',
schema: appsync.SchemaFile.fromAsset(path.join(__dirname, 'schema.graphql')),
});
```
**catatan**
Dalam lingkup`add_api`, kami menambahkan API GraphQL baru menggunakan kata kunci yang diikuti `new` oleh. `appsync.GraphqlApi(scope: Construct, id: string , props: GraphqlApiProps)` Cakupan kami adalah`this`, id CFN adalah`graphQL-example`, dan alat peraga kami adalah `my-first-api` (nama API di konsol) dan `schema.graphql` (jalur absolut ke file skema).
Untuk menambahkan sumber data, pertama-tama Anda harus menambahkan sumber data ke tumpukan. Kemudian, Anda perlu mengaitkannya dengan GraphQL API menggunakan metode khusus sumber. Asosiasi akan terjadi ketika Anda membuat fungsi resolver Anda. Sementara itu, mari kita gunakan contoh dengan membuat tabel DynamoDB menggunakan: `dynamodb.Table`
```
const add_ddb_table = new dynamodb.Table(this, 'posts-table', {
partitionKey: {
name: 'id',
type: dynamodb.AttributeType.STRING,
},
});
```
**catatan**
Jika kita menggunakan ini dalam contoh kita, kita akan menambahkan tabel DynamoDB baru dengan id CFN `posts-table` dari dan kunci partisi. `id (S)`
Selanjutnya, kita perlu mengimplementasikan resolver kita di file stack. Berikut adalah contoh kueri sederhana yang memindai semua item dalam tabel DynamoDB:
```
const add_func = new appsync.AppsyncFunction(this, 'func-get-posts', {
name: 'get_posts_func_1',
add_api,
dataSource: add_api.addDynamoDbDataSource('table-for-posts', add_ddb_table),
code: appsync.Code.fromInline(`
export function request(ctx) {
return { operation: 'Scan' };
}
export function response(ctx) {
return ctx.result.items;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
});
new appsync.Resolver(this, 'pipeline-resolver-get-posts', {
add_api,
typeName: 'Query',
fieldName: 'getPost',
code: appsync.Code.fromInline(`
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
pipelineConfig: [add_func],
});
```
**catatan**
Pertama, kami membuat fungsi yang disebut`add_func`. Urutan pembuatan ini mungkin tampak agak berlawanan dengan intuisi, tetapi Anda harus membuat fungsi di resolver pipeline Anda sebelum Anda membuat resolver itu sendiri. Sebuah fungsi mengikuti formulir:
```
AppsyncFunction(scope: Construct, id: string, props: AppsyncFunctionProps)
```
Ruang lingkup kami adalah`this`, id CFN kami`func-get-posts`, dan alat peraga kami berisi detail fungsi yang sebenarnya. Di dalam alat peraga, kami menyertakan:
Fungsi `name` yang akan hadir di AWS AppSync konsol (`get_posts_func_1`).
GraphQL API yang kita buat sebelumnya (). `add_api`
Sumber data; ini adalah titik di mana kita menghubungkan sumber data ke nilai GraphQL API, lalu melampirkannya ke fungsi. Kami mengambil tabel yang kami buat (`add_ddb_table`) dan melampirkannya ke GraphQL API `add_api` () menggunakan salah `GraphqlApi` satu metode (). [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.GraphqlApi.html#addwbrdynamowbrdbwbrdatawbrsourceid-table-options](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.GraphqlApi.html#addwbrdynamowbrdbwbrdatawbrsourceid-table-options) Nilai id (`table-for-posts`) adalah nama sumber data di AWS AppSync konsol. Untuk daftar metode khusus sumber, lihat halaman berikut:
[ DynamoDbDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.DynamoDbDataSource.html)
[ EventBridgeDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.EventBridgeDataSource.html)
[ HttpDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.HttpDataSource.html)
[ LambdaDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.LambdaDataSource.html)
[ NoneDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.NoneDataSource.html)
[ OpenSearchDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.OpenSearchDataSource.html)
[ RdsDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.RdsDataSource.html)
Kode berisi permintaan fungsi dan penangan respons, yang merupakan pemindaian dan pengembalian sederhana.
Runtime menentukan bahwa kita ingin menggunakan APPSYNC\$1JS runtime versi 1.0.0. Perhatikan bahwa saat ini satu-satunya versi yang tersedia untuk APPSYNC\$1JS.
Selanjutnya, kita perlu melampirkan fungsi ke resolver pipa. Kami membuat resolver kami menggunakan formulir:
```
Resolver(scope: Construct, id: string, props: ResolverProps)
```
Ruang lingkup kami adalah`this`, id CFN kami`pipeline-resolver-get-posts`, dan alat peraga kami berisi detail fungsi yang sebenarnya. Di dalam alat peraga, kami menyertakan:
GraphQL API yang kita buat sebelumnya (). `add_api`
Nama tipe objek khusus; ini adalah operasi query, jadi kita hanya menambahkan nilai`Query`.
Nama bidang (`getPost`) adalah nama bidang dalam skema di bawah `Query` tipe.
Kode berisi penangan sebelum dan sesudah Anda. Contoh kami hanya mengembalikan hasil apa pun yang ada dalam konteks setelah fungsi melakukan operasinya.
Runtime menentukan bahwa kita ingin menggunakan APPSYNC\$1JS runtime versi 1.0.0. Perhatikan bahwa saat ini satu-satunya versi yang tersedia untuk APPSYNC\$1JS.
Konfigurasi pipeline berisi referensi ke fungsi yang kita buat (`add_func`).
------
Untuk meringkas apa yang terjadi dalam contoh ini, Anda melihat AWS AppSync fungsi yang menerapkan permintaan dan penangan respons. Fungsi ini bertanggung jawab untuk berinteraksi dengan sumber data Anda. Handler permintaan mengirim `Scan` operasi ke AWS AppSync, menginstruksikannya tentang operasi apa yang harus dilakukan terhadap sumber data DynamoDB Anda. Response handler mengembalikan daftar item (`ctx.result.items`). Daftar item kemudian dipetakan ke tipe `Post` GraphQL secara otomatis.
## Membuat resolver mutasi dasar
Bagian ini akan menunjukkan cara membuat resolver mutasi dasar.
------
#### [ Console ]
1. Masuk ke Konsol Manajemen AWS dan buka [AppSynckonsol](https://console.aws.amazon.com/appsync/).
1. Di **APIs dasbor**, pilih GraphQL API Anda.
1. Di **Sidebar**, pilih **Skema**.
1. Di bawah bagian **Resolvers** dan jenis **Mutasi**, pilih **Lampirkan di sebelah bidang** Anda.
**catatan**
Dalam contoh kita, kita melampirkan resolver untuk`createPost`, yang menambahkan `Post` objek ke tabel kita. Mari kita asumsikan kita menggunakan tabel DynamoDB yang sama dari bagian terakhir. Kunci partisi diatur ke `id` dan kosong.
1. Pada halaman **Attach resolver**, di bawah jenis **Resolver**, pilih. `pipeline resolvers` [Sebagai pengingat, Anda dapat menemukan informasi lebih lanjut tentang resolver di sini.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-components.html) Untuk **runtime Resolver, pilih `APPSYNC_JS` untuk mengaktifkan runtime**. JavaScript
1. Anda dapat mengaktifkan [caching](https://docs.aws.amazon.com/appsync/latest/devguide/enabling-caching.html) untuk API ini. Sebaiknya matikan fitur ini untuk saat ini. Pilih **Buat**.
1. Pilih **Tambah fungsi**, lalu pilih **Buat fungsi baru**. Atau, Anda mungkin melihat tombol **Create function** untuk memilih sebagai gantinya.
1. Pilih sumber data Anda. Ini harus menjadi sumber yang datanya akan Anda manipulasi dengan mutasi.
1. Masukkan a`Function name`.
1. Di bawah **kode Fungsi**, Anda harus mengimplementasikan perilaku fungsi. Ini adalah mutasi, jadi permintaan idealnya akan melakukan beberapa operasi perubahan status pada sumber data yang dipanggil. Hasilnya akan diproses oleh fungsi respons.
**catatan**
`createPost`menambahkan, atau “menempatkan”, yang baru `Post` dalam tabel dengan parameter kami sebagai data. Kita bisa menambahkan sesuatu seperti ini:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Pada langkah ini, kami juga menambahkan `request` dan `response` berfungsi:
`request`: Handler permintaan menerima konteks sebagai argumen. Pernyataan pengembalian request handler melakukan [https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem](https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem)perintah, yang merupakan operasi DynamoDB bawaan ([lihat](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-2.html) di sini [atau](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) di sini untuk contoh). `PutItem`Perintah menambahkan `Post` objek ke tabel DynamoDB kami dengan mengambil nilai `key` partisi (dihasilkan secara otomatis `util.autoid()` oleh) `attributes` dan dari input argumen konteks (ini adalah nilai yang akan kami berikan dalam permintaan kami). `key`Itu adalah `id` dan `attributes` adalah argumen `title` lapangan `date` dan. Keduanya diformat sebelumnya melalui [https://docs.aws.amazon.com//appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html#utility-helpers-in-toMap-js](https://docs.aws.amazon.com//appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html#utility-helpers-in-toMap-js)helper untuk bekerja dengan tabel DynamoDB.
`response`: Respons menerima konteks yang diperbarui dan mengembalikan hasil penangan permintaan.
1. Pilih **Buat** setelah selesai.
1. Kembali ke layar resolver, di bawah **Fungsi**, pilih drop-down **Tambah fungsi** dan tambahkan fungsi Anda ke daftar fungsi Anda.
1. Pilih **Simpan** untuk memperbarui resolver.
------
#### [ CLI ]
**Untuk menambahkan fungsi Anda**
+ Buat fungsi untuk resolver pipeline Anda menggunakan perintah. `[create-function](https://docs.aws.amazon.com/cli/latest/reference/appsync/create-function.html)`
Anda harus memasukkan beberapa parameter untuk perintah khusus ini:
1. API Anda. `api-id`
1. `name`Fungsi di AWS AppSync konsol.
1. Itu`data-source-name`, atau nama sumber data yang akan digunakan fungsi. Itu harus sudah dibuat dan ditautkan ke GraphQL API Anda di layanan. AWS AppSync
1. atau lingkungan dan bahasa dari fungsi tersebut. `runtime` Untuk JavaScript, nama harus`APPSYNC_JS`, dan runtime,`1.0.0`.
1. Penangan`code`, atau permintaan dan respons fungsi Anda. Meskipun Anda dapat mengetiknya secara manual, jauh lebih mudah untuk menambahkannya ke file.txt (atau format serupa) kemudian meneruskannya sebagai argumen.
**catatan**
Kode kueri kami akan berada dalam file yang diteruskan sebagai argumen:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Contoh perintah mungkin terlihat seperti ini:
```
aws appsync create-function \
--api-id abcdefghijklmnopqrstuvwxyz \
--name add_posts_func_1 \
--data-source-name table-for-posts \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
Output akan dikembalikan dalam CLI. Inilah contohnya:
```
{
"functionConfiguration": {
"functionId": "vulcmbfcxffiram63psb4dduoa",
"functionArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/functions/vulcmbfcxffiram63psb4dduoa",
"name": "add_posts_func_1",
"dataSourceName": "table-for-posts",
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output foes here"
}
}
```
**catatan**
Pastikan Anda merekam `functionId` suatu tempat karena ini akan digunakan untuk melampirkan fungsi ke resolver.
**Untuk membuat resolver Anda**
+ Buat fungsi pipeline `Mutation` dengan menjalankan `[create-resolver](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)` perintah.
Anda harus memasukkan beberapa parameter untuk perintah khusus ini:
1. API Anda. `api-id`
1. Jenis objek`type-name`, atau khusus dalam skema Anda (Query, Mutation, Subscription).
1. Operasi`field-name`, atau bidang di dalam jenis objek khusus yang ingin Anda lampirkan resolver.
1. The`kind`, yang menentukan unit atau resolver pipa. Setel ini `PIPELINE` untuk mengaktifkan fungsi pipeline.
1. The`pipeline-config`, atau fungsi (s) untuk melampirkan ke resolver. Pastikan Anda mengetahui `functionId` nilai-nilai fungsi Anda. Urutan daftar penting.
1. Yang`runtime`, yang `APPSYNC_JS` (JavaScript). `runtimeVersion`Saat ini adalah`1.0.0`.
1. Itu`code`, yang berisi langkah sebelum dan sesudah.
**catatan**
Kode kueri kami akan berada dalam file yang diteruskan sebagai argumen:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
const { id, ...values } = ctx.args;
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id }),
attributeValues: util.dynamodb.toMapValues(values),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Contoh perintah mungkin terlihat seperti ini:
```
aws appsync create-resolver \
--api-id abcdefghijklmnopqrstuvwxyz \
--type-name Mutation \
--field-name createPost \
--kind PIPELINE \
--pipeline-config functions=vulcmbfcxffiram63psb4dduoa \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
Output akan dikembalikan dalam CLI. Inilah contohnya:
```
{
"resolver": {
"typeName": "Mutation",
"fieldName": "createPost",
"resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Mutation/resolvers/createPost",
"kind": "PIPELINE",
"pipelineConfig": {
"functions": [
"vulcmbfcxffiram63psb4dduoa"
]
},
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
------
#### [ CDK ]
**Tip**
[Sebelum Anda menggunakan CDK, kami sarankan untuk meninjau [dokumentasi resmi](https://docs.aws.amazon.com/cdk/v2/guide/home.html) CDK bersama dengan referensi CDK AWS AppSync.](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html)
Langkah-langkah yang tercantum di bawah ini hanya akan menampilkan contoh umum dari cuplikan yang digunakan untuk menambahkan sumber daya tertentu. Ini **tidak** dimaksudkan untuk menjadi solusi yang berfungsi dalam kode produksi Anda. Kami juga menganggap Anda sudah memiliki aplikasi yang berfungsi.
+ Untuk membuat mutasi, dengan asumsi Anda berada di proyek yang sama, Anda dapat menambahkannya ke file tumpukan seperti kueri. Berikut adalah fungsi dan resolver yang dimodifikasi untuk mutasi yang menambahkan yang baru `Post` ke tabel:
```
const add_func_2 = new appsync.AppsyncFunction(this, 'func-add-post', {
name: 'add_posts_func_1',
add_api,
dataSource: add_api.addDynamoDbDataSource('table-for-posts-2', add_ddb_table),
code: appsync.Code.fromInline(`
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
export function response(ctx) {
return ctx.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
});
new appsync.Resolver(this, 'pipeline-resolver-create-posts', {
add_api,
typeName: 'Mutation',
fieldName: 'createPost',
code: appsync.Code.fromInline(`
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
pipelineConfig: [add_func_2],
});
```
**catatan**
Karena mutasi dan kueri ini terstruktur dengan cara yang sama, kami hanya akan menjelaskan perubahan yang kami buat untuk membuat mutasi.
Dalam fungsinya, kami mengubah id CFN menjadi `func-add-post` dan nama `add_posts_func_1` untuk mencerminkan fakta bahwa kami menambahkan `Posts` ke tabel. Di sumber data, kami membuat asosiasi baru ke table (`add_ddb_table`) kami di AWS AppSync konsol `table-for-posts-2` karena `addDynamoDbDataSource` metode memerlukannya. Perlu diingat, asosiasi baru ini masih menggunakan tabel yang sama yang kita buat sebelumnya, tetapi kita sekarang memiliki dua koneksi ke sana di AWS AppSync konsol: satu untuk kueri sebagai `table-for-posts` dan satu untuk mutasi sebagai`table-for-posts-2`. Kode diubah untuk menambahkan a `Post` dengan menghasilkan `id` nilainya secara otomatis dan menerima masukan klien untuk bidang lainnya.
Dalam resolver, kita mengubah nilai id `pipeline-resolver-create-posts` untuk mencerminkan fakta bahwa kita menambahkan `Posts` ke tabel. Untuk mencerminkan mutasi dalam skema, nama tipe diubah menjadi`Mutation`, dan nama,. `createPost` Konfigurasi pipeline disetel ke fungsi mutasi baru kami. `add_func_2`
------
Untuk meringkas apa yang terjadi dalam contoh ini, AWS AppSync secara otomatis mengonversi argumen yang ditentukan di `createPost` bidang dari skema GraphQL Anda menjadi operasi DynamoDB. Contoh menyimpan catatan di DynamoDB menggunakan kunci`id`, yang secara otomatis dibuat menggunakan helper kami. `util.autoId()` Semua bidang lain yang Anda berikan ke argumen konteks (`ctx.args.input`) dari permintaan yang dibuat di AWS AppSync konsol atau sebaliknya akan disimpan sebagai atribut tabel. Baik kunci dan atribut secara otomatis dipetakan ke format DynamoDB yang kompatibel menggunakan helper. `util.dynamodb.toMapValues(values)`
AWS AppSync juga mendukung alur kerja pengujian dan debug untuk mengedit resolver. Anda dapat menggunakan `context` objek tiruan untuk melihat nilai template yang diubah sebelum memanggilnya. Secara opsional, Anda dapat melihat permintaan lengkap ke sumber data secara interaktif saat menjalankan kueri. Untuk informasi selengkapnya, lihat [Menguji dan debug resolvers (JavaScript)](https://docs.aws.amazon.com/appsync/latest/devguide/test-debug-resolvers-js.html) serta [Monitoring](https://docs.aws.amazon.com/appsync/latest/devguide/monitoring.html#aws-appsync-monitoring) dan logging.
## Resolver tingkat lanjut
Jika Anda mengikuti bagian pagination opsional dalam [Merancang skema Anda](designing-your-schema.md#aws-appsync-designing-your-schema), Anda masih perlu menambahkan resolver Anda ke permintaan Anda untuk menggunakan pagination. Contoh kami menggunakan pagination query yang dipanggil `getPosts` untuk mengembalikan hanya sebagian dari hal-hal yang diminta pada suatu waktu. Kode resolver kami di bidang itu mungkin terlihat seperti ini:
```
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
const { limit = 20, nextToken } = ctx.args;
return { operation: 'Scan', limit, nextToken };
}
/**
* @returns the result of the `put` operation
*/
export function response(ctx) {
const { items: posts = [], nextToken } = ctx.result;
return { posts, nextToken };
}
```
Dalam permintaan, kami lulus dalam konteks permintaan. Kami `limit` adalah*20*, artinya kami mengembalikan hingga 20 `Posts` di kueri pertama. `nextToken`Kursor kami diperbaiki ke `Post` entri pertama di sumber data. Ini diteruskan ke argumen. Permintaan kemudian melakukan pemindaian dari yang pertama `Post` hingga nomor batas pemindaian. Sumber data menyimpan hasil dalam konteks, yang diteruskan ke respons. Respons mengembalikan `Posts` itu diambil, kemudian menetapkan `nextToken` diatur ke `Post` entri tepat setelah batas. Permintaan berikutnya dikirim untuk melakukan hal yang sama persis tetapi dimulai dari offset tepat setelah kueri pertama. Perlu diingat bahwa permintaan semacam ini dilakukan secara berurutan dan tidak secara paralel.
# Menguji dan men-debug resolver di () AWS AppSync JavaScript
AWS AppSync mengeksekusi resolver pada bidang GraphQL terhadap sumber data. Saat bekerja dengan resolver pipeline, fungsi berinteraksi dengan sumber data Anda. Seperti yang dijelaskan dalam [ikhtisar JavaScript resolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html), fungsi berkomunikasi dengan sumber data dengan menggunakan penangan permintaan dan respons yang ditulis JavaScript dan dijalankan pada runtime. `APPSYNC_JS` Ini memungkinkan Anda untuk memberikan logika dan kondisi khusus sebelum dan sesudah berkomunikasi dengan sumber data.
Untuk membantu pengembang menulis, menguji, dan men-debug resolver ini, AWS AppSync konsol juga menyediakan alat untuk membuat permintaan dan respons GraphQL dengan data tiruan ke penyelesai bidang individual. Selain itu, Anda dapat melakukan kueri, mutasi, dan langganan di AWS AppSync konsol dan melihat aliran log terperinci dari seluruh permintaan dari Amazon. CloudWatch Ini termasuk hasil dari sumber data.
## Pengujian dengan data tiruan
Ketika resolver GraphQL dipanggil, itu berisi objek yang memiliki informasi `context` yang relevan tentang permintaan. Ini termasuk argumen dari klien, informasi identitas, dan data dari bidang GraphQL induk. Ini juga menyimpan hasil dari sumber data, yang dapat digunakan dalam penangan respons. Untuk informasi selengkapnya tentang struktur ini dan utilitas pembantu yang tersedia untuk digunakan saat pemrograman, lihat referensi [objek konteks Resolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html).
Saat menulis atau mengedit fungsi resolver, Anda dapat meneruskan objek *konteks *tiruan* atau pengujian* ke editor konsol. Ini memungkinkan Anda untuk melihat bagaimana permintaan dan penangan respons mengevaluasi tanpa benar-benar berjalan terhadap sumber data. Misalnya, Anda dapat lulus `firstname: Shaggy` argumen pengujian dan melihat bagaimana itu mengevaluasi saat menggunakan `ctx.args.firstname` dalam kode template Anda. Anda juga dapat menguji evaluasi setiap pembantu utilitas seperti `util.autoId()` atau`util.time.nowISO8601()`.
### Menguji penyelesai
Contoh ini akan menggunakan AWS AppSync konsol untuk menguji resolver.
1. Masuk ke Konsol Manajemen AWS dan buka [AppSynckonsol](https://console.aws.amazon.com/appsync/).
1. Di **APIs dasbor**, pilih GraphQL API Anda.
1. Di **Sidebar**, pilih **Functions**.
1. Pilih fungsi yang ada.
1. Di bagian atas halaman **fungsi Perbarui**, **pilih Pilih konteks pengujian**, lalu pilih **Buat konteks baru**.
1. Pilih objek konteks sampel atau isi JSON secara manual di jendela **Konfigurasi konteks pengujian** di bawah ini.
1. Masukkan **nama konteks Teks**.
1. Pilih tombol **Simpan**.
1. **Untuk mengevaluasi resolver Anda menggunakan objek konteks tiruan ini, pilih Run Test.**
Untuk contoh yang lebih praktis, misalkan Anda memiliki aplikasi yang menyimpan tipe `Dog` GraphQL yang menggunakan pembuatan ID otomatis untuk objek dan menyimpannya di Amazon DynamoDB. Anda juga ingin menulis beberapa nilai dari argumen mutasi GraphQL dan hanya mengizinkan pengguna tertentu untuk melihat respons. Cuplikan berikut menunjukkan seperti apa skema itu:
```
type Dog {
breed: String
color: String
}
type Mutation {
addDog(firstname: String, age: Int): Dog
}
```
Anda dapat menulis AWS AppSync fungsi dan menambahkannya ke `addDog` resolver Anda untuk menangani mutasi. Untuk menguji AWS AppSync fungsi Anda, Anda dapat mengisi objek konteks seperti contoh berikut. Berikut ini memiliki argumen dari klien `name` dan`age`, dan `username` diisi dalam `identity` objek:
```
{
"arguments" : {
"firstname": "Shaggy",
"age": 4
},
"source" : {},
"result" : {
"breed" : "Miniature Schnauzer",
"color" : "black_grey"
},
"identity": {
"sub" : "uuid",
"issuer" : " https://cognito-idp.{region}.amazonaws.com/{userPoolId}",
"username" : "Nadia",
"claims" : { },
"sourceIp" :[ "x.x.x.x" ],
"defaultAuthStrategy" : "ALLOW"
}
}
```
Anda dapat menguji AWS AppSync fungsi Anda menggunakan kode berikut:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id: util.autoId() }),
attributeValues: util.dynamodb.toMapValues(ctx.args),
};
}
export function response(ctx) {
if (ctx.identity.username === 'Nadia') {
console.log("This request is allowed")
return ctx.result;
}
util.unauthorized();
}
```
Handler permintaan dan respons yang dievaluasi memiliki data dari objek konteks pengujian Anda dan nilai yang dihasilkan dari. `util.autoId()` Selain itu, jika Anda mengubah `username` ke nilai selain`Nadia`, hasilnya tidak akan dikembalikan karena pemeriksaan otorisasi akan gagal. Untuk informasi selengkapnya tentang kontrol akses berbutir halus, lihat Kasus penggunaan [otorisasi](security-authorization-use-cases.md#aws-appsync-security-authorization-use-cases).
### Menguji permintaan dan penangan respons dengan's AWS AppSync APIs
Anda dapat menggunakan perintah `EvaluateCode` API untuk menguji kode Anda dari jarak jauh dengan data tiruan. Untuk memulai dengan perintah, pastikan Anda telah menambahkan `appsync:evaluateMappingCode` izin ke kebijakan Anda. Contoh:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "appsync:evaluateCode",
"Resource": "arn:aws:appsync:us-east-1:111122223333:*"
}
]
}
```
------
Anda dapat memanfaatkan perintah dengan menggunakan [AWS CLI](https://aws.amazon.com/cli/)atau [AWS SDKs](https://aws.amazon.com/tools/). Misalnya, ambil `Dog` skema dan permintaan AWS AppSync fungsinya dan penangan respons dari bagian sebelumnya. Menggunakan CLI di stasiun lokal Anda, simpan kode ke file bernama`code.js`, lalu simpan `context` objek ke file bernama. `context.json` Dari shell Anda, jalankan perintah berikut:
```
$ aws appsync evaluate-code \
--code file://code.js \
--function response \
--context file://context.json \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0
```
Responsnya `evaluationResult` berisi muatan yang dikembalikan oleh handler Anda. Ini juga berisi `logs` objek, yang memegang daftar log yang dihasilkan oleh handler Anda selama evaluasi. Hal ini memudahkan untuk men-debug eksekusi kode Anda dan melihat informasi tentang evaluasi Anda untuk membantu memecahkan masalah. Contoh:
```
{
"evaluationResult": "{\"breed\":\"Miniature Schnauzer\",\"color\":\"black_grey\"}",
"logs": [
"INFO - code.js:13:5: \"This request is allowed\""
]
}
```
`evaluationResult`Dapat diurai sebagai JSON, yang memberikan:
```
{
"breed": "Miniature Schnauzer",
"color": "black_grey"
}
```
Dengan menggunakan SDK, Anda dapat dengan mudah menggabungkan pengujian dari rangkaian pengujian favorit untuk memvalidasi perilaku penangan Anda. Sebaiknya buat pengujian menggunakan [Jest Testing Framework](https://jestjs.io/), tetapi rangkaian pengujian apa pun berfungsi. Cuplikan berikut menunjukkan validasi hipotetis berjalan. Perhatikan bahwa kami mengharapkan respons evaluasi menjadi JSON yang valid, jadi kami gunakan `JSON.parse` untuk mengambil JSON dari respons string:
```
const AWS = require('aws-sdk')
const fs = require('fs')
const client = new AWS.AppSync({ region: 'us-east-2' })
const runtime = {name:'APPSYNC_JS',runtimeVersion:'1.0.0')
test('request correctly calls DynamoDB', async () => {
const code = fs.readFileSync('./code.js', 'utf8')
const context = fs.readFileSync('./context.json', 'utf8')
const contextJSON = JSON.parse(context)
const response = await client.evaluateCode({ code, context, runtime, function: 'request' }).promise()
const result = JSON.parse(response.evaluationResult)
expect(result.key.id.S).toBeDefined()
expect(result.attributeValues.firstname.S).toEqual(contextJSON.arguments.firstname)
})
```
Ini menghasilkan hasil sebagai berikut:
```
Ran all test suites.
> jest
PASS ./index.test.js
✓ request correctly calls DynamoDB (543 ms)
Test Suites: 1 passed, 1 total
Tests: 1 passed, 1 total
Snapshots: 0 totalTime: 1.511 s, estimated 2 s
```
## Mendebug kueri langsung
Tidak ada pengganti untuk end-to-end pengujian dan logging untuk men-debug aplikasi produksi. AWS AppSync memungkinkan Anda mencatat kesalahan dan detail permintaan lengkap menggunakan Amazon CloudWatch. Selain itu, Anda dapat menggunakan AWS AppSync konsol untuk menguji kueri GraphQL, mutasi, dan langganan serta data log streaming langsung untuk setiap permintaan kembali ke editor kueri untuk di-debug secara real time. Untuk langganan, log menampilkan informasi waktu koneksi.
Untuk melakukan ini, Anda harus mengaktifkan CloudWatch log Amazon terlebih dahulu, seperti yang dijelaskan dalam [Pemantauan dan pencatatan](monitoring.md#aws-appsync-monitoring). Selanjutnya, di AWS AppSync konsol, pilih tab **Queries dan kemudian masukkan kueri** GraphQL yang valid. Di bagian kanan bawah, klik dan seret jendela **Log** untuk membuka tampilan log. Di bagian atas halaman, pilih ikon panah putar untuk menjalankan kueri GraphQL Anda. Dalam beberapa saat, log permintaan dan respons lengkap Anda untuk operasi dialirkan ke bagian ini dan Anda dapat melihatnya di konsol.
# Mengkonfigurasi dan menggunakan resolver pipeline di () AWS AppSync JavaScript
AWS AppSync mengeksekusi resolver pada bidang GraphQL. Dalam beberapa kasus, aplikasi memerlukan eksekusi beberapa operasi untuk menyelesaikan satu bidang GraphQL. Dengan resolver pipeline, pengembang sekarang dapat membuat operasi yang disebut Fungsi dan menjalankannya secara berurutan. Pipeline resolver berguna untuk aplikasi yang, misalnya, memerlukan melakukan pemeriksaan otorisasi sebelum mengambil data untuk bidang.
Untuk informasi selengkapnya tentang arsitektur resolver JavaScript pipeline, lihat ikhtisar [JavaScriptresolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html#anatomy-of-a-pipeline-resolver-js).
## Langkah 1: Membuat resolver pipa
Di AWS AppSync konsol, buka halaman **Skema**.
Simpan skema berikut:
```
schema {
query: Query
mutation: Mutation
}
type Mutation {
signUp(input: Signup): User
}
type Query {
getUser(id: ID!): User
}
input Signup {
username: String!
email: String!
}
type User {
id: ID!
username: String
email: AWSEmail
}
```
**Kita akan memasang resolver pipa ke bidang **SignUp** pada tipe Mutasi.** Pada tipe **Mutasi** di sisi kanan, pilih **Lampirkan** di sebelah bidang `signUp` mutasi. Atur resolver ke `pipeline resolver` dan `APPSYNC_JS` runtime, lalu buat resolver.
Pipeline resolver kami mendaftarkan pengguna dengan terlebih dahulu memvalidasi input alamat email dan kemudian menyimpan pengguna dalam sistem. **Kami akan merangkum validasi email di dalam fungsi **ValidateEmail dan penyimpanan pengguna di dalam fungsi SaveUser**.** **Fungsi **ValidateEmail** dijalankan terlebih dahulu, dan jika email valid, maka fungsi SaveUser dijalankan.**
Alur eksekusi adalah sebagai berikut:
1. Mutation.signup penangan permintaan resolver
1. fungsi ValidateEmail
1. Fungsi SaveUser
1. Penangan respons penyelesai mutasi.signup
Karena kami mungkin akan menggunakan kembali fungsi **ValidateEmail** di resolver lain di API kami, kami ingin menghindari mengakses `ctx.args` karena ini akan berubah dari satu bidang GraphQL ke bidang GraphQL lainnya. Sebagai gantinya, kita dapat menggunakan `ctx.stash` untuk menyimpan atribut email dari argumen field `signUp(input: Signup)` input.
Perbarui kode resolver Anda dengan mengganti fungsi permintaan dan respons Anda:
```
export function request(ctx) {
ctx.stash.email = ctx.args.input.email
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
```
Pilih **Buat** atau **Simpan** untuk memperbarui resolver.
## Langkah 2: Membuat fungsi
Dari halaman resolver pipeline, di bagian **Functions**, klik **Add function**, lalu **Create new** function. Dimungkinkan juga untuk membuat fungsi tanpa melalui halaman resolver; untuk melakukan ini, di AWS AppSync konsol, buka halaman **Fungsi**. Pilih tombol **Create Function**. Mari buat fungsi yang memeriksa apakah email valid dan berasal dari domain tertentu. Jika email tidak valid, fungsi tersebut menimbulkan kesalahan. Jika tidak, itu meneruskan input apa pun yang diberikan.
Pastikan Anda telah membuat sumber data dari tipe **NONE**. Pilih sumber data ini di daftar **Nama sumber data**. Untuk **nama fungsi**, masukkan`validateEmail`. Di area **kode fungsi**, timpa semuanya dengan cuplikan ini:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { email } = ctx.stash;
const valid = util.matches(
'^[a-zA-Z0-9_.+-]+@(?:(?:[a-zA-Z0-9-]+\.)?[a-zA-Z]+\.)?(myvaliddomain)\.com',
email
);
if (!valid) {
util.error(`"${email}" is not a valid email.`);
}
return { payload: { email } };
}
export function response(ctx) {
return ctx.result;
}
```
Tinjau input Anda, lalu pilih **Buat**. Kami baru saja membuat fungsi **ValidateEmail** kami. ****Ulangi langkah-langkah ini untuk membuat fungsi SaveUser dengan kode berikut (Demi kesederhanaan, kami menggunakan sumber data NONE dan berpura-pura pengguna telah disimpan dalam sistem setelah fungsi dijalankan.**** ):
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
return ctx.prev.result;
}
export function response(ctx) {
ctx.result.id = util.autoId();
return ctx.result;
}
```
Kami baru saja membuat fungsi **SaveUser** kami.
## Langkah 3: Menambahkan fungsi ke resolver pipa
Fungsi kita seharusnya ditambahkan secara otomatis ke resolver pipeline yang baru saja kita buat. Jika ini tidak terjadi, atau Anda membuat fungsi melalui halaman **Fungsi**, Anda dapat mengklik **Tambah fungsi** kembali pada halaman `signUp` resolver untuk melampirkannya. Tambahkan fungsi **ValidateEmail** **dan SaveUser ke resolver**. **Fungsi **ValidateEmail** harus ditempatkan sebelum fungsi SaveUser.** Saat Anda menambahkan lebih banyak fungsi, Anda dapat menggunakan opsi **pindah ke atas** dan **bergerak ke bawah** untuk mengatur ulang urutan eksekusi fungsi Anda. Tinjau perubahan Anda, lalu pilih **Simpan**.
## Langkah 4: Menjalankan kueri
Di AWS AppSync konsol, buka halaman **Kueri.** Di penjelajah, pastikan Anda menggunakan mutasi Anda. Jika tidak, pilih `Mutation` di daftar drop-down, lalu pilih`+`. Masukkan kueri berikut:
```
mutation {
signUp(input: {email: "nadia@myvaliddomain.com", username: "nadia"}) {
id
username
}
}
```
Ini harus mengembalikan sesuatu seperti:
```
{
"data": {
"signUp": {
"id": "256b6cc2-4694-46f4-a55e-8cb14cc5d7fc",
"username": "nadia"
}
}
}
```
Kami telah berhasil mendaftarkan pengguna kami dan memvalidasi email input menggunakan resolver pipeline.