Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# AWS AppSync referensi resolver () JavaScript
Bagian berikut berisi referensi `APPSYNC_JS` runtime dan JavaScript resolver:
+ [ JavaScriptikhtisar resolvers](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html) - Pelajari lebih lanjut tentang cara kerja resolver. AWS AppSync
+ [Referensi objek konteks penyelesai - Pelajari lebih lanjut tentang objek konteks dan cara penggunaannya dalam resolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html).
+ [ JavaScript fitur runtime untuk resolver dan fungsi](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html) - Pelajari lebih lanjut tentang fitur runtime yang didukung dan menggunakan utilitas untuk menyederhanakan kode.
+ [ JavaScriptreferensi fungsi resolver untuk DynamoDB - Pelajari lebih lanjut tentang bagaimana resolver berinteraksi dengan DynamoDB](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html).
+ [ JavaScriptreferensi fungsi resolver untuk OpenSearch ](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-elasticsearch-js.html) - Pelajari lebih lanjut tentang permintaan resolver dan struktur respons serta interaksi dengan Layanan. OpenSearch
+ [ JavaScript referensi fungsi resolver untuk Lambda](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-lambda-js.html) - Pelajari lebih lanjut tentang permintaan resolver dan struktur respons serta interaksi dengan Lambda.
+ [ JavaScriptreferensi fungsi resolver untuk sumber EventBridge data](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-eventbridge-js.html) - Pelajari lebih lanjut tentang permintaan resolver dan struktur respons serta interaksi dengan. EventBridge
+ [ JavaScript referensi fungsi resolver untuk sumber data None](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-none-js.html) - Pelajari lebih lanjut tentang permintaan resolver dan struktur respons serta interaksi dengan sumber data NONE.
+ [ JavaScript referensi fungsi resolver untuk HTTP](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-http-js.html) - Pelajari lebih lanjut tentang permintaan resolver dan struktur respons serta interaksi dengan titik akhir HTTP.
+ [ JavaScript referensi fungsi resolver untuk Amazon RDS](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-rds-js.html) - Pelajari lebih lanjut tentang struktur resolver dan interaksi dengan RDS.
+ [ JavaScript referensi fungsi resolver untuk Amazon Bedrock](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-bedrock-js.html) - Pelajari lebih lanjut tentang struktur resolver dan interaksi dengan Amazon Bedrock.
# AWS AppSync JavaScript ikhtisar penyelesai
AWS AppSync memungkinkan Anda menanggapi permintaan GraphQL dengan melakukan operasi pada sumber data Anda. Untuk setiap bidang GraphQL yang ingin Anda jalankan kueri, mutasi, atau langganan, resolver harus dilampirkan.
Resolver adalah konektor antara GraphQL dan sumber data. Mereka memberi tahu AWS AppSync cara menerjemahkan permintaan GraphQL yang masuk ke dalam instruksi untuk sumber data backend Anda dan bagaimana menerjemahkan respons dari sumber data itu kembali ke respons GraphQL. Dengan AWS AppSync, Anda dapat menulis resolver Anda menggunakan JavaScript dan menjalankannya di lingkungan AWS AppSync (`APPSYNC_JS`).
AWS AppSync memungkinkan Anda untuk menulis resolver unit atau resolver pipa yang terdiri dari beberapa AWS AppSync fungsi dalam pipa.
## Fitur runtime yang didukung
AWS AppSync JavaScript Runtime menyediakan subset JavaScript pustaka, utilitas, dan fitur. Untuk daftar lengkap fitur dan fungsionalitas yang didukung oleh `APPSYNC_JS` runtime, lihat [fitur JavaScript runtime untuk resolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html) dan fungsi.
## Penyelesai unit
Unit resolver terdiri dari kode yang mendefinisikan permintaan dan respon handler yang dijalankan terhadap sumber data. Handler permintaan mengambil objek konteks sebagai argumen dan mengembalikan payload permintaan yang digunakan untuk memanggil sumber data Anda. Response handler menerima payload kembali dari sumber data dengan hasil dari permintaan yang dieksekusi. Response handler mengubah payload menjadi respons GraphQL untuk menyelesaikan bidang GraphQL. Dalam contoh di bawah ini, resolver mengambil item dari sumber data DynamoDB:
```
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;
```
## Anatomi penyelesai JavaScript pipa
Pipeline resolver terdiri dari kode yang mendefinisikan permintaan dan respon handler dan daftar fungsi. Setiap fungsi memiliki **permintaan** dan **respon** handler yang dijalankan terhadap sumber data. Karena delegasi penyelesai pipa berjalan ke daftar fungsi, oleh karena itu tidak ditautkan ke sumber data apa pun. Resolver dan fungsi unit adalah primitif yang menjalankan operasi terhadap sumber data.
### Penangan permintaan penyelesai pipa
Handler permintaan dari resolver pipeline (langkah sebelumnya) memungkinkan Anda untuk melakukan beberapa logika persiapan sebelum menjalankan fungsi yang ditentukan.
### Daftar fungsi
Daftar fungsi resolver pipeline akan berjalan secara berurutan. Hasil evaluasi penangan permintaan penyelesai pipa tersedia untuk fungsi pertama sebagai. `ctx.prev.result` Setiap hasil evaluasi fungsi tersedia untuk fungsi berikutnya sebagai`ctx.prev.result`.
### Penangan respons penyelesai pipa
Response handler dari pipeline resolver memungkinkan Anda untuk melakukan beberapa logika akhir dari output fungsi terakhir ke tipe bidang GraphQL yang diharapkan. Output dari fungsi terakhir dalam daftar fungsi tersedia di pengendali respons penyelesai pipa sebagai atau. `ctx.prev.result` `ctx.result`
### Aliran eksekusi
Mengingat resolver pipeline yang terdiri dari dua fungsi, daftar di bawah ini mewakili alur eksekusi saat resolver dipanggil:
1. Penangan permintaan penyelesai pipa
1. Fungsi 1: Fungsi permintaan handler
1. Fungsi 1: Pemanggilan sumber data
1. Fungsi 1: Fungsi respon handler
1. Fungsi 2: Fungsi permintaan handler
1. Fungsi 2: Pemanggilan sumber data
1. Fungsi 2: Fungsi respon handler
1. Penangan respons penyelesai pipa
![\[GraphQL request flow diagram showing interactions between request, data sources, and response components.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/appsync-js-resolver-logic.png)
### Utilitas bawaan `APPSYNC_JS` runtime yang berguna
Utilitas berikut dapat membantu Anda ketika Anda bekerja dengan resolver pipa.
#### ctx.stash
Stash adalah objek yang tersedia di dalam setiap resolver dan permintaan fungsi dan penangan respons. Instans simpanan yang sama hidup melalui satu resolver run. Ini berarti Anda dapat menggunakan stash untuk meneruskan data arbitrer di seluruh penangan permintaan dan respons dan di seluruh fungsi dalam resolver pipeline. Anda dapat menguji simpanan seperti JavaScript objek biasa.
#### ctx.prev.result
`ctx.prev.result`Ini merupakan hasil dari operasi sebelumnya yang dieksekusi dalam pipa. Jika operasi sebelumnya adalah penangan permintaan resolver pipa, maka `ctx.prev.result` tersedia untuk fungsi pertama dalam rantai. Jika operasi sebelumnya adalah fungsi pertama, maka `ctx.prev.result` mewakili output dari fungsi pertama dan tersedia untuk fungsi kedua dalam pipa. Jika operasi sebelumnya adalah fungsi terakhir, maka `ctx.prev.result` mewakili output dari fungsi terakhir dan tersedia untuk pengendali respon resolver pipeline.
#### util.error
`util.error`Utilitas ini berguna untuk melempar kesalahan bidang. Menggunakan `util.error` di dalam permintaan fungsi atau penangan respons akan segera menimbulkan kesalahan bidang, yang mencegah fungsi berikutnya dieksekusi. Untuk detail selengkapnya dan `util.error` tanda tangan lainnya, kunjungi [fitur JavaScript runtime untuk resolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html) dan fungsi.
#### Util.appenError
`util.appendError`mirip dengan`util.error()`, dengan perbedaan utama bahwa itu tidak mengganggu evaluasi handler. Sebaliknya, ini menandakan ada kesalahan dengan bidang, tetapi memungkinkan penangan untuk dievaluasi dan akibatnya mengembalikan data. Menggunakan fungsi `util.appendError` di dalam tidak akan mengganggu aliran eksekusi pipa. Untuk detail selengkapnya dan `util.error` tanda tangan lainnya, kunjungi [fitur JavaScript runtime untuk resolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html) dan fungsi.
#### Runtime.earlyReturn
`runtime.earlyReturn`Fungsi ini memungkinkan Anda untuk kembali sebelum waktunya dari fungsi permintaan apa pun. Menggunakan `runtime.earlyReturn` bagian dalam penangan permintaan resolver akan kembali dari resolver. Memanggilnya dari penangan permintaan AWS AppSync fungsi akan kembali dari fungsi dan akan melanjutkan proses ke fungsi berikutnya di pipeline atau penangan respons resolver.
### Menulis resolver pipa
Penyelesai pipa juga memiliki permintaan dan penangan respons yang mengelilingi fungsi dalam pipeline: penangan permintaannya dijalankan sebelum permintaan fungsi pertama, dan penangan responsnya dijalankan setelah respons fungsi terakhir. Handler permintaan resolver dapat mengatur data yang akan digunakan oleh fungsi dalam pipeline. Handler respons resolver bertanggung jawab untuk mengembalikan data yang dipetakan ke tipe keluaran bidang GraphQL. Dalam contoh di bawah ini, penangan permintaan resolver, mendefinisikan`allowedGroups`; data yang dikembalikan harus milik salah satu grup ini. Nilai ini dapat digunakan oleh fungsi resolver untuk meminta data. Response handler resolver melakukan pemeriksaan akhir dan memfilter hasilnya untuk memastikan bahwa hanya item milik grup yang diizinkan yang dikembalikan.
```
import { util } from '@aws-appsync/utils';
/**
* Called before the request function of the first AppSync function in the pipeline.
* @param ctx the context object holds contextual information about the function invocation.
*/
export function request(ctx) {
ctx.stash.allowedGroups = ['admin'];
ctx.stash.startedAt = util.time.nowISO8601();
return {};
}
/**
* Called after the response function of the last AppSync function in the pipeline.
* @param ctx the context object holds contextual information about the function invocation.
*/
export function response(ctx) {
const result = [];
for (const item of ctx.prev.result) {
if (ctx.stash.allowedGroups.indexOf(item.group) > -1) result.push(item);
}
return result;
}
```
#### AWS AppSync Fungsi menulis
AWS AppSync fungsi memungkinkan Anda untuk menulis logika umum yang dapat Anda gunakan kembali di beberapa resolver dalam skema Anda. Misalnya, Anda dapat memiliki satu AWS AppSync fungsi `QUERY_ITEMS` yang dipanggil yang bertanggung jawab untuk menanyakan item dari sumber data Amazon DynamoDB. Untuk resolver yang ingin Anda kueri dengan item, cukup tambahkan fungsi ke pipeline resolver dan berikan indeks kueri yang akan digunakan. Logika tidak harus diimplementasikan kembali.
## Topik tambahan
**Topik**
+ [Contoh pipeline resolver dengan Amazon DynamoDB](https://docs.aws.amazon.com/appsync/latest/devguide/writing-code.html)
+ [Mengkonfigurasi utilitas untuk runtime `APPSYNC_JS`](https://docs.aws.amazon.com/appsync/latest/devguide/utility-resolvers.html)
+ [Bundling, TypeScript, dan peta sumber untuk runtime `APPSYNC_JS`](https://docs.aws.amazon.com/appsync/latest/devguide/additional-utilities.html)
+ [Menguji resolver dan penangan fungsi Anda](https://docs.aws.amazon.com/appsync/latest/devguide/test-resolvers.html)
+ [Migrasi dari VTL ke JavaScript](https://docs.aws.amazon.com/appsync/latest/devguide/migrating-resolvers.html)
+ [Memilih antara akses sumber data langsung dan proxy melalui sumber data Lambda](https://docs.aws.amazon.com/appsync/latest/devguide/choosing-data-source.html)
# Contoh pipeline resolver dengan Amazon DynamoDB
Misalkan Anda ingin melampirkan resolver pipeline pada bidang bernama `getPost(id:ID!)` yang mengembalikan `Post` tipe dari sumber data Amazon DynamoDB dengan kueri GraphQL berikut:
```
getPost(id:1){
id
title
content
}
```
Pertama, lampirkan resolver sederhana `Query.getPost` dengan kode di bawah ini. Ini adalah contoh kode resolver sederhana. Tidak ada logika yang didefinisikan dalam penangan permintaan, dan penangan respons hanya mengembalikan hasil dari fungsi terakhir.
```
/**
* Invoked **before** the request handler of the first AppSync function in the pipeline.
* The resolver `request` handler allows to perform some preparation logic
* before executing the defined functions in your pipeline.
* @param ctx the context object holds contextual information about the function invocation.
*/
export function request(ctx) {
return {}
}
/**
* Invoked **after** the response handler of the last AppSync function in the pipeline.
* The resolver `response` handler allows to perform some final evaluation logic
* from the output of the last function to the expected GraphQL field type.
* @param ctx the context object holds contextual information about the function invocation.
*/
export function response(ctx) {
return ctx.prev.result
}
```
Selanjutnya, tentukan fungsi `GET_ITEM` yang mengambil postitem dari sumber data Anda:
```
import { util } from '@aws-appsync/utils'
import * as ddb from '@aws-appsync/utils/dynamodb'
/**
* Request a single item from the attached DynamoDB table datasource
* @param ctx the context object holds contextual information about the function invocation.
*/
export function request(ctx) {
const { id } = ctx.args
return ddb.get({ key: { id } })
}
/**
* Returns the result
* @param ctx the context object holds contextual information about the function invocation.
*/
export function response(ctx) {
const { error, result } = ctx
if (error) {
return util.appendError(error.message, error.type, result)
}
return ctx.result
}
```
Jika ada kesalahan selama permintaan, penangan respons fungsi menambahkan kesalahan yang akan dikembalikan ke klien pemanggil dalam respons GraphQL. Tambahkan `GET_ITEM` fungsi ke daftar fungsi resolver Anda. Saat Anda menjalankan kueri, penangan permintaan `GET_ITEM` fungsi menggunakan utilitas yang disediakan oleh modul AWS AppSync DynamoDB untuk membuat `DynamoDBGetItem` permintaan menggunakan sebagai kunci. `id` `ddb.get({ key: { id } })`menghasilkan `GetItem` operasi yang sesuai:
```
{
"operation" : "GetItem",
"key" : {
"id" : { "S" : "1" }
}
}
```
AWS AppSync menggunakan permintaan untuk mengambil data dari Amazon DynamoDB. Setelah data dikembalikan, itu ditangani oleh penangan respons `GET_ITEM` fungsi, yang memeriksa kesalahan dan kemudian mengembalikan hasilnya.
```
{
"result" : {
"id": 1,
"title": "hello world",
"content": ""
}
}
```
Akhirnya, handler respon resolver mengembalikan hasilnya secara langsung.
## Bekerja dengan kesalahan
Jika terjadi kesalahan dalam fungsi Anda selama permintaan, kesalahan akan tersedia di pengendali respons fungsi Anda di`ctx.error`. Anda dapat menambahkan kesalahan ke respons GraphQL Anda menggunakan utilitas. `util.appendError` Anda dapat membuat kesalahan tersedia untuk fungsi lain dalam pipeline dengan menggunakan simpanan. Lihat contoh di bawah ini:
```
/**
* Returns the result
* @param ctx the context object holds contextual information about the function invocation.
*/
export function response(ctx) {
const { error, result } = ctx;
if (error) {
if (!ctx.stash.errors) ctx.stash.errors = []
ctx.stash.errors.push(ctx.error)
return util.appendError(error.message, error.type, result);
}
return ctx.result;
}
```
# Mengkonfigurasi utilitas untuk runtime `APPSYNC_JS`
AWS AppSync menyediakan dua pustaka yang membantu dalam pengembangan resolver dengan runtime: `APPSYNC_JS`
+ `@aws-appsync/eslint-plugin`- Menangkap dan memperbaiki masalah dengan cepat selama pengembangan.
+ `@aws-appsync/utils`- Menyediakan validasi tipe dan pelengkapan otomatis di editor kode.
## Mengkonfigurasi plugin eslint
[ESLint](https://eslint.org/)adalah alat yang menganalisis kode Anda secara statis untuk menemukan masalah dengan cepat. Anda dapat menjalankan ESLint sebagai bagian dari pipeline integrasi berkelanjutan Anda. `@aws-appsync/eslint-plugin`adalah ESLint plugin yang menangkap sintaks yang tidak valid dalam kode Anda saat memanfaatkan runtime. `APPSYNC_JS` Plugin ini memungkinkan Anda untuk dengan cepat mendapatkan umpan balik tentang kode Anda selama pengembangan tanpa harus mendorong perubahan Anda ke cloud.
`@aws-appsync/eslint-plugin`menyediakan dua set aturan yang dapat Anda gunakan selama pengembangan.
**“plugin: @aws -appsync/base”** mengonfigurasi seperangkat aturan dasar yang dapat Anda manfaatkan dalam proyek Anda:
| Aturan | Deskripsi |
| --- | --- |
| tidak-asinkron | Proses dan janji asinkron tidak didukung. |
| tidak-menunggu | Proses dan janji asinkron tidak didukung. |
| tidak ada kelas | Kelas tidak didukung. |
| tidak-untuk | fortidak didukung (kecuali untuk for-in danfor-of, yang didukung) |
| tidak lanjutkan | continue tidak didukung. |
| tidak ada generator | Generator tidak didukung. |
| tanpa hasil | yield tidak didukung. |
| tanpa label | Label tidak didukung. |
| tidak-ini | thisKata kunci tidak didukung. |
| tidak mencoba | Struktur coba/tangkap tidak didukung. |
| tidak-sementara | Sementara loop tidak didukung. |
| no-disallowed-unary-operators | \$1\$1,--, dan operator \$1 unary tidak diizinkan. |
| no-disallowed-binary-operators | instanceofOperator tidak diperbolehkan. |
| tidak ada janji | Proses dan janji asinkron tidak didukung. |
**“plugin: @aws -appsync/recommended”** menyediakan beberapa aturan tambahan tetapi juga mengharuskan Anda untuk menambahkan TypeScript konfigurasi ke proyek Anda.
| Aturan | Deskripsi |
| --- | --- |
| tidak ada rekursi | Panggilan fungsi rekursif tidak diperbolehkan. |
| no-disallowed-methods | Beberapa metode tidak diperbolehkan. Lihat [referensi](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html) untuk set lengkap fungsi bawaan yang didukung. |
| no-function-passing | Melewati fungsi sebagai argumen fungsi ke fungsi tidak diperbolehkan. |
| no-function-reassign | Fungsi tidak dapat dipindahkan. |
| no-function-return | Fungsi tidak dapat menjadi nilai kembali fungsi. |
Untuk menambahkan plugin ke proyek Anda, ikuti langkah-langkah instalasi dan penggunaan di [Memulai dengan ESLint](https://eslint.org/docs/latest/user-guide/getting-started#installation-and-usage). Kemudian, instal [plugin](https://www.npmjs.com/package/@aws-appsync/eslint-plugin) di proyek Anda menggunakan manajer paket proyek Anda (misalnya, npm, yarn, atau pnpm):
```
$ npm install @aws-appsync/eslint-plugin
```
Di `.eslintrc.{js,yml,json}` file Anda, tambahkan **“plugin: @aws -appsync/base” atau **“plugin: @aws -appsync/recommended**”** ke properti. `extends` Cuplikan di bawah ini adalah `.eslintrc` konfigurasi sampel dasar untuk: JavaScript
```
{
"extends": ["plugin:@aws-appsync/base"]
}
```
Untuk menggunakan set aturan **“plugin: @aws -appsync/recommended”**, instal ketergantungan yang diperlukan:
```
$ npm install -D @typescript-eslint/parser
```
Kemudian, buat `.eslintrc.js` file:
```
{
"parser": "@typescript-eslint/parser",
"parserOptions": {
"ecmaVersion": 2018,
"project": "./tsconfig.json"
},
"extends": ["plugin:@aws-appsync/recommended"]
}
```
# Bundling, TypeScript, dan peta sumber untuk runtime `APPSYNC_JS`
TypeScript meningkatkan AWS AppSync pengembangan dengan menyediakan keamanan tipe dan deteksi kesalahan dini. Anda dapat menulis TypeScript kode secara lokal dan mentranspilasinya JavaScript sebelum menggunakannya dengan runtime. `APPSYNC_JS` Prosesnya dimulai dengan menginstal TypeScript dan mengonfigurasi tsconfig.json untuk lingkungan. `APPSYNC_JS` Anda kemudian dapat menggunakan alat bundling seperti esbuild untuk mengkompilasi dan menggabungkan kode. Amplify CLI akan menghasilkan tipe dari skema GraphQL, memungkinkan Anda untuk menggunakan tipe ini dalam kode resolver.
Anda dapat memanfaatkan pustaka kustom dan eksternal dalam resolver dan kode fungsi Anda, selama mereka memenuhi persyaratan. `APPSYNC_JS` Alat bundling menggabungkan kode menjadi satu file untuk digunakan. AWS AppSync Peta sumber dapat disertakan untuk membantu debugging.
## Memanfaatkan pustaka dan menggabungkan kode Anda
Dalam resolver dan kode fungsi Anda, Anda dapat memanfaatkan pustaka kustom dan eksternal selama mereka memenuhi persyaratan. `APPSYNC_JS` Hal ini memungkinkan untuk menggunakan kembali kode yang ada dalam aplikasi Anda. Untuk menggunakan pustaka yang ditentukan oleh beberapa file, Anda harus menggunakan alat bundling, seperti [esbuild](https://esbuild.github.io/), untuk menggabungkan kode Anda dalam satu file yang kemudian dapat disimpan ke AWS AppSync resolver atau fungsi Anda.
Saat menggabungkan kode Anda, ingatlah hal berikut:
+ `APPSYNC_JS`hanya mendukung ECMAScript modul (ESM).
+ `@aws-appsync/*`modul diintegrasikan ke dalam `APPSYNC_JS` dan tidak boleh dibundel dengan kode Anda.
+ Lingkungan `APPSYNC_JS` runtime mirip dengan NodeJS dalam kode itu tidak berjalan di lingkungan browser.
+ Anda dapat menyertakan peta sumber opsional. Namun, jangan sertakan konten sumber.
Untuk mempelajari lebih lanjut tentang peta sumber, lihat [Menggunakan peta sumber](#source-maps).
Misalnya, untuk menggabungkan kode resolver Anda yang terletak di`src/appsync/getPost.resolver.js`, Anda dapat menggunakan perintah esbuild CLI berikut:
```
$ esbuild --bundle \
--sourcemap=inline \
--sources-content=false \
--target=esnext \
--platform=node \
--format=esm \
--external:@aws-appsync/utils \
--outdir=out/appsync \
src/appsync/getPost.resolver.js
```
## Membangun kode Anda dan bekerja dengan TypeScript
[TypeScript](https://www.typescriptlang.org/)adalah bahasa pemrograman yang dikembangkan oleh Microsoft yang menawarkan semua fitur bersama dengan sistem TypeScript pengetikan. JavaScript Anda dapat menggunakan TypeScript untuk menulis kode type-safe dan menangkap kesalahan dan bug pada waktu pembuatan sebelum menyimpan kode Anda. AWS AppSync`@aws-appsync/utils`Paket ini sepenuhnya diketik.
`APPSYNC_JS`Runtime tidak mendukung TypeScript secara langsung. Anda harus terlebih dahulu mentranspile TypeScript kode Anda ke JavaScript kode yang didukung `APPSYNC_JS` runtime sebelum menyimpan kode Anda. AWS AppSync Anda dapat menggunakannya TypeScript untuk menulis kode Anda di lingkungan pengembangan terintegrasi lokal (IDE), tetapi perhatikan bahwa Anda tidak dapat membuat TypeScript kode di AWS AppSync konsol.
Untuk memulai, pastikan Anda telah [TypeScript](https://www.typescriptlang.org/download)menginstal di proyek Anda. Kemudian, konfigurasikan pengaturan TypeScript transkompilasi Anda agar berfungsi dengan `APPSYNC_JS` runtime yang digunakan. [TSConfig](https://www.typescriptlang.org/tsconfig) Berikut adalah contoh `tsconfig.json` file dasar yang dapat Anda gunakan:
```
// tsconfig.json
{
"compilerOptions": {
"target": "esnext",
"module": "esnext",
"noEmit": true,
"moduleResolution": "node",
}
}
```
Anda kemudian dapat menggunakan alat bundling seperti esbuild untuk mengkompilasi dan menggabungkan kode Anda. Misalnya, mengingat proyek dengan AWS AppSync kode Anda berada di`src/appsync`, Anda dapat menggunakan perintah berikut untuk mengkompilasi dan menggabungkan kode Anda:
```
$ esbuild --bundle \
--sourcemap=inline \
--sources-content=false \
--target=esnext \
--platform=node \
--format=esm \
--external:@aws-appsync/utils \
--outdir=out/appsync \
src/appsync/**/*.ts
```
### Menggunakan Amplify codegen
Anda dapat menggunakan [Amplify CLI](https://docs.amplify.aws/cli/) untuk menghasilkan tipe untuk skema Anda. Dari direktori tempat `schema.graphql` file Anda berada, jalankan perintah berikut dan tinjau petunjuk untuk mengonfigurasi codegen Anda:
```
$ npx @aws-amplify/cli codegen add
```
Untuk membuat ulang codegen Anda dalam keadaan tertentu (misalnya, ketika skema Anda diperbarui), jalankan perintah berikut:
```
$ npx @aws-amplify/cli codegen
```
Anda kemudian dapat menggunakan tipe yang dihasilkan dalam kode resolver Anda. Misalnya, diberikan skema berikut:
```
type Todo {
id: ID!
title: String!
description: String
}
type Mutation {
createTodo(title: String!, description: String): Todo
}
type Query {
listTodos: Todo
}
```
Anda dapat menggunakan tipe yang dihasilkan dalam AWS AppSync fungsi contoh berikut:
```
import { Context, util } from '@aws-appsync/utils'
import * as ddb from '@aws-appsync/utils/dynamodb'
import { CreateTodoMutationVariables, Todo } from './API' // codegen
export function request(ctx: Context) {
ctx.args.description = ctx.args.description ?? 'created on ' + util.time.nowISO8601()
return ddb.put({ key: { id: util.autoId() }, item: ctx.args })
}
export function response(ctx) {
return ctx.result as Todo
}
```
### Menggunakan obat generik di TypeScript
Anda dapat menggunakan obat generik dengan beberapa jenis yang disediakan. Misalnya, cuplikan di bawah ini adalah `Todo` tipe:
```
export type Todo = {
__typename: "Todo",
id: string,
title: string,
description?: string | null,
};
```
Anda dapat menulis resolver untuk langganan yang memanfaatkan. `Todo` Di IDE Anda, definisi ketik dan petunjuk pelengkapan otomatis akan memandu Anda menggunakan utilitas `toSubscriptionFilter` transformasi dengan benar:
```
import { util, Context, extensions } from '@aws-appsync/utils'
import { Todo } from './API'
export function request(ctx: Context) {
return {}
}
export function response(ctx: Context) {
const filter = util.transform.toSubscriptionFilter({
title: { beginsWith: 'hello' },
description: { contains: 'created' },
})
extensions.setSubscriptionFilter(filter)
return null
}
```
## Linting bundel Anda
Anda dapat secara otomatis lint bundel Anda dengan mengimpor plugin. `esbuild-plugin-eslint` Anda kemudian dapat mengaktifkannya dengan memberikan `plugins` nilai yang memungkinkan kemampuan eslint. Di bawah ini adalah cuplikan yang menggunakan esbuild JavaScript API dalam file bernama: `build.mjs`
```
/* eslint-disable */
import { build } from 'esbuild'
import eslint from 'esbuild-plugin-eslint'
import glob from 'glob'
const files = await glob('src/**/*.ts')
await build({
format: 'esm',
target: 'esnext',
platform: 'node',
external: ['@aws-appsync/utils'],
outdir: 'dist/',
entryPoints: files,
bundle: true,
plugins: [eslint({ useEslintrc: true })],
})
```
## Menggunakan peta sumber
Anda dapat memberikan peta sumber inline (`sourcemap`) dengan JavaScript kode Anda. Peta sumber berguna ketika Anda bundel JavaScript atau TypeScript kode dan ingin melihat referensi ke file sumber input Anda di log dan pesan JavaScript kesalahan runtime Anda.
Anda `sourcemap` harus muncul di akhir kode Anda. Ini didefinisikan oleh satu baris komentar yang mengikuti format berikut:
```
//# sourceMappingURL=data:application/json;base64,
```
Inilah contohnya:
```
//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsibGliLmpzIiwgImNvZGUuanMiXSwKICAibWFwcGluZ3MiOiAiO0FBQU8sU0FBUyxRQUFRO0FBQ3RCLFNBQU87QUFDVDs7O0FDRE8sU0FBUyxRQUFRLEtBQUs7QUFDM0IsU0FBTyxNQUFNO0FBQ2Y7IiwKICAibmFtZXMiOiBbXQp9Cg==
```
Peta sumber dapat dibuat dengan esbuild. Contoh di bawah ini menunjukkan cara menggunakan esbuild JavaScript API untuk menyertakan peta sumber sebaris saat kode dibuat dan dibundel:
```
/* eslint-disable */
import { build } from 'esbuild'
import eslint from 'esbuild-plugin-eslint'
import glob from 'glob'
const files = await glob('src/**/*.ts')
await build({
sourcemap: 'inline',
sourcesContent: false,
format: 'esm',
target: 'esnext',
platform: 'node',
external: ['@aws-appsync/utils'],
outdir: 'dist/',
entryPoints: files,
bundle: true,
plugins: [eslint({ useEslintrc: true })],
})
```
Secara khusus, `sourcesContent` opsi `sourcemap` dan menentukan bahwa peta sumber harus ditambahkan sebaris di akhir setiap build tetapi tidak boleh menyertakan konten sumber. Sebagai konvensi, kami sarankan untuk tidak menyertakan konten sumber dalam Anda`sourcemap`. Anda dapat menonaktifkan ini di esbuild dengan menyetel `sources-content` ke`false`.
Untuk mengilustrasikan cara kerja peta sumber, tinjau contoh berikut di mana kode resolver mereferensikan fungsi pembantu dari pustaka pembantu. Kode berisi pernyataan log dalam kode resolver dan di pustaka pembantu:
**. /src/default.resolver.ts** (resolver Anda)
```
import { Context } from '@aws-appsync/utils'
import { hello, logit } from './helper'
export function request(ctx: Context) {
console.log('start >')
logit('hello world', 42, true)
console.log('< end')
return 'test'
}
export function response(ctx: Context): boolean {
hello()
return ctx.prev.result
}
```
**.src/helper.ts** (file pembantu)
```
export const logit = (...rest: any[]) => {
// a special logger
console.log('[logger]', ...rest.map((r) => `<${r}>`))
}
export const hello = () => {
// This just returns a simple sentence, but it could do more.
console.log('i just say hello..')
}
```
Saat Anda membangun dan menggabungkan file resolver, kode resolver Anda akan menyertakan peta sumber inline. Saat resolver Anda berjalan, entri berikut akan muncul di log: CloudWatch
![\[CloudWatch log entries showing resolver code execution with inline source map information.\]](http://docs.aws.amazon.com/id_id/appsync/latest/devguide/images/cloudwatch-sourcemap.jpeg)
Melihat entri di CloudWatch log, Anda akan melihat bahwa fungsionalitas dari dua file telah dibundel bersama dan berjalan secara bersamaan. Nama file asli dari setiap file juga tercermin dengan jelas dalam log.
# Menguji resolver dan penangan fungsi Anda di AWS AppSync
Anda dapat menggunakan perintah `EvaluateCode` API untuk menguji resolver dan penangan fungsi Anda dari jarak jauh dengan data tiruan sebelum menyimpan kode Anda ke resolver atau fungsi. Untuk memulai dengan perintah, pastikan Anda telah menambahkan `appsync:evaluatecode` 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://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/index.html) atau. [AWS SDKs](https://aws.amazon.com/tools/) Misalnya, untuk menguji kode Anda menggunakan CLI, cukup arahkan ke file Anda, berikan konteks, dan tentukan handler yang ingin Anda evaluasi:
```
aws appsync evaluate-code \
--code file://code.js \
--function request \
--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 menyimpan 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": "{\"operation\":\"PutItem\",\"key\":{\"id\":{\"S\":\"record-id\"}},\"attributeValues\":{\"owner\":{\"S\":\"John doe\"},\"expectedVersion\":{\"N\":2},\"authorId\":{\"S\":\"Sammy Davis\"}}}",
"logs": [
"INFO - code.js:5:3: \"current id\" \"record-id\"",
"INFO - code.js:9:3: \"request evaluated\""
]
}
```
Hasil evaluasi dapat diuraikan sebagai JSON, yang memberikan:
```
{
"operation": "PutItem",
"key": {
"id": {
"S": "record-id"
}
},
"attributeValues": {
"owner": {
"S": "John doe"
},
"expectedVersion": {
"N": 2
},
"authorId": {
"S": "Sammy Davis"
}
}
}
```
Dengan menggunakan SDK, Anda dapat dengan mudah menggabungkan pengujian dari rangkaian pengujian untuk memvalidasi perilaku kode Anda. Contoh kami di sini 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
```
# Bermigrasi dari VTL ke in JavaScript AWS AppSync
AWS AppSync memungkinkan Anda untuk menulis logika bisnis Anda untuk resolver dan fungsi Anda menggunakan VTL atau. JavaScript Dengan kedua bahasa, Anda menulis logika yang menginstruksikan AWS AppSync layanan tentang cara berinteraksi dengan sumber data Anda. Dengan VTL, Anda menulis template pemetaan yang harus mengevaluasi ke string yang dikodekan JSON yang valid. Dengan JavaScript, Anda menulis penangan permintaan dan respons yang mengembalikan objek. Anda tidak mengembalikan string yang dikodekan JSON.
Misalnya, ambil template pemetaan VTL berikut untuk mendapatkan item Amazon DynamoDB:
```
{
"operation": "GetItem",
"key": {
"id": $util.dynamodb.toDynamoDBJson($ctx.args.id),
}
}
```
Utilitas `$util.dynamodb.toDynamoDBJson` mengembalikan string JSON-encoded. Jika `$ctx.args.id` disetel ke``, template mengevaluasi ke string yang dikodekan JSON yang valid:
```
{
"operation": "GetItem",
"key": {
"id": {"S": ""},
}
}
```
Saat bekerja dengan JavaScript, Anda tidak perlu mencetak string mentah yang disandikan JSON dalam kode Anda, dan menggunakan utilitas seperti tidak diperlukan. `toDynamoDBJson` Contoh yang setara dari template pemetaan di atas adalah:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
return {
operation: 'GetItem',
key: {id: util.dynamodb.toDynamoDB(ctx.args.id)}
};
}
```
Alternatifnya adalah menggunakan`util.dynamodb.toMapValues`, yang merupakan pendekatan yang direkomendasikan untuk menangani objek nilai:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
return {
operation: 'GetItem',
key: util.dynamodb.toMapValues({ id: ctx.args.id }),
};
}
```
Ini mengevaluasi untuk:
```
{
"operation": "GetItem",
"key": {
"id": {
"S": ""
}
}
}
```
**catatan**
Sebaiknya gunakan modul DynamoDB dengan sumber data DynamoDB:
```
import * as ddb from '@aws-appsync/utils/dynamodb'
export function request(ctx) {
ddb.get({ key: { id: ctx.args.id } })
}
```
Sebagai contoh lain, ambil template pemetaan berikut untuk menempatkan item di sumber data Amazon DynamoDB:
```
{
"operation" : "PutItem",
"key" : {
"id": $util.dynamodb.toDynamoDBJson($util.autoId()),
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
Saat dievaluasi, string template pemetaan ini harus menghasilkan string yang dikodekan JSON yang valid. Saat menggunakan JavaScript, kode Anda mengembalikan objek permintaan secara langsung:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { id = util.autoId(), ...values } = ctx.args;
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id }),
attributeValues: util.dynamodb.toMapValues(values),
};
}
```
yang mengevaluasi untuk:
```
{
"operation": "PutItem",
"key": {
"id": { "S": "2bff3f05-ff8c-4ed8-92b4-767e29fc4e63" }
},
"attributeValues": {
"firstname": { "S": "Shaggy" },
"age": { "N": 4 }
}
}
```
**catatan**
Sebaiknya gunakan modul DynamoDB dengan sumber data DynamoDB:
```
import { util } from '@aws-appsync/utils'
import * as ddb from '@aws-appsync/utils/dynamodb'
export function request(ctx) {
const { id = util.autoId(), ...item } = ctx.args
return ddb.put({ key: { id }, item })
}
```
# Memilih antara akses sumber data langsung dan proxy melalui sumber data Lambda
Dengan AWS AppSync dan `APPSYNC_JS` runtime, Anda dapat menulis kode Anda sendiri yang mengimplementasikan logika bisnis kustom Anda dengan menggunakan AWS AppSync fungsi untuk mengakses sumber data Anda. Ini memudahkan Anda untuk berinteraksi langsung dengan sumber data seperti Amazon DynamoDB, Aurora Tanpa OpenSearch Server, Layanan, HTTP APIs, AWS dan layanan lainnya tanpa harus menggunakan layanan atau infrastruktur komputasi tambahan. AWS AppSync juga memudahkan untuk berinteraksi dengan AWS Lambda fungsi dengan mengkonfigurasi sumber data Lambda. Sumber data Lambda memungkinkan Anda menjalankan logika bisnis yang kompleks menggunakan AWS Lambda kemampuan set lengkap untuk menyelesaikan permintaan GraphQL. Dalam kebanyakan kasus, AWS AppSync fungsi yang terhubung langsung ke sumber data targetnya akan menyediakan semua fungsionalitas yang Anda butuhkan. Dalam situasi di mana Anda perlu menerapkan logika bisnis kompleks yang tidak didukung oleh `APPSYNC_JS` runtime, Anda dapat menggunakan sumber data Lambda sebagai proxy untuk berinteraksi dengan sumber data target Anda.
| | | |
| --- |--- |--- |
| | Integrasi sumber data langsung | Sumber data Lambda sebagai proxy |
| Kasus penggunaan | AWS AppSync fungsi berinteraksi langsung dengan sumber data API. | AWS AppSync fungsi memanggil Lambdas yang berinteraksi dengan sumber data API. |
| Waktu Aktif | APPSYNC\$1JS (JavaScript) | Setiap runtime Lambda yang didukung |
| Ukuran maksimum kode | 32.000 karakter per fungsi AWS AppSync | 50 MB (zip, untuk diunggah langsung) per Lambda |
| Modul eksternal | Terbatas - APPSYNC\$1JS hanya mendukung fitur | Ya |
| Hubungi AWS layanan apa pun | Ya - Menggunakan sumber data AWS AppSync HTTP | Ya - Menggunakan AWS SDK |
| Akses ke header permintaan | Ya | Ya |
| Akses jaringan | Tidak | Ya |
| Akses sistem file | Tidak | Ya |
| Pencatatan dan metrik | Ya | Ya |
| Membangun dan menguji sepenuhnya di dalam AppSync | Ya | Tidak |
| Awal yang dingin | Tidak | Tidak - Dengan konkurensi yang disediakan |
| Penskalaan otomatis | Ya - secara transparan oleh AWS AppSync | Ya - Seperti yang dikonfigurasi di Lambda |
| Harga | Tidak ada biaya tambahan | Dibebankan untuk penggunaan Lambda |
AWS AppSync fungsi yang terintegrasi langsung dengan sumber data target mereka ideal untuk kasus penggunaan seperti berikut:
+ Berinteraksi dengan Amazon DynamoDB, Aurora Tanpa Server, dan Layanan OpenSearch
+ Berinteraksi dengan HTTP APIs dan meneruskan header yang masuk
+ Berinteraksi dengan AWS layanan menggunakan sumber data HTTP (dengan AWS AppSync secara otomatis menandatangani permintaan dengan peran sumber data yang disediakan)
+ Menerapkan kontrol akses sebelum mengakses sumber data
+ Menerapkan penyaringan data yang diambil sebelum memenuhi permintaan
+ Menerapkan orkestrasi sederhana dengan eksekusi AWS AppSync fungsi secara berurutan dalam pipa resolver
+ Mengontrol koneksi caching dan berlangganan dalam kueri dan mutasi.
AWS AppSync fungsi yang menggunakan sumber data Lambda sebagai proxy sangat ideal untuk kasus penggunaan seperti berikut:
+ Menggunakan bahasa selain JavaScript atau Velocity Template Language (VTL)
+ Menyesuaikan dan mengendalikan CPU atau memori untuk mengoptimalkan kinerja
+ Mengimpor pustaka pihak ketiga atau memerlukan fitur yang tidak didukung di `APPSYNC_JS`
+ Membuat beberapa permintaan jaringan and/or mendapatkan akses sistem file untuk memenuhi kueri
+ Permintaan batching menggunakan konfigurasi [batching](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-lambda-js.html).
# AWS AppSync JavaScript referensi objek konteks resolver
AWS AppSync mendefinisikan satu set variabel dan fungsi untuk bekerja dengan permintaan dan penangan respon. Ini membuat operasi logis pada data lebih mudah dengan GraphQL. Dokumen ini menjelaskan fungsi-fungsi tersebut dan memberikan contoh.
## Mengakses `context`
`context`Argumen penangan permintaan dan respons adalah objek yang menyimpan semua informasi kontekstual untuk pemanggilan resolver Anda. Ini memiliki struktur sebagai berikut:
```
type Context = {
arguments: any;
args: any;
identity: Identity;
source: any;
error?: {
message: string;
type: string;
};
stash: any;
result: any;
prev: any;
request: Request;
info: Info;
};
```
**catatan**
Anda akan sering menemukan bahwa `context` objek tersebut disebut sebagai`ctx`.
Setiap bidang dalam `context` objek didefinisikan sebagai berikut:
### `context`bidang
** `arguments` **
Peta yang berisi semua argumen GraphQL untuk bidang ini.
** `identity` **
Objek yang berisi informasi tentang penelepon. Untuk informasi selengkapnya tentang struktur bidang ini, lihat [Identitas](#aws-appsync-resolver-context-reference-identity-js).
** `source` **
Peta yang berisi resolusi bidang induk.
** `stash` **
Stash adalah objek yang tersedia di dalam setiap resolver dan function handler. Objek simpanan yang sama hidup melalui satu resolver run. Ini berarti Anda dapat menggunakan stash untuk meneruskan data arbitrer di seluruh penangan permintaan dan respons dan di seluruh fungsi dalam resolver pipeline.
Anda tidak dapat menghapus atau mengganti seluruh simpanan, tetapi Anda dapat menambahkan, memperbarui, menghapus, dan membaca properti simpanan.
Anda dapat menambahkan item ke simpanan dengan memodifikasi salah satu contoh kode di bawah ini:
```
//Example 1
ctx.stash.newItem = { key: "something" }
//Example 2
Object.assign(ctx.stash, {key1: value1, key2: value})
```
Anda dapat menghapus item dari simpanan dengan memodifikasi kode di bawah ini:
```
delete ctx.stash.key
```
** `result` **
Wadah untuk hasil resolver ini. Bidang ini hanya tersedia untuk penangan respons.
Misalnya, jika Anda menyelesaikan `author` bidang kueri berikut:
```
query {
getPost(id: 1234) {
postId
title
content
author {
id
name
}
}
}
```
Kemudian `context` variabel lengkap tersedia ketika penangan respons dievaluasi:
```
{
"arguments" : {
id: "1234"
},
"source": {},
"result" : {
"postId": "1234",
"title": "Some title",
"content": "Some content",
"author": {
"id": "5678",
"name": "Author Name"
}
},
"identity" : {
"sourceIp" : ["x.x.x.x"],
"userArn" : "arn:aws:iam::123456789012:user/appsync",
"accountId" : "666666666666",
"user" : "AIDAAAAAAAAAAAAAAAAAA"
}
}
```
** `prev.result` **
Hasil dari operasi apa pun sebelumnya dijalankan dalam resolver pipa.
Jika operasi sebelumnya adalah penangan permintaan penyelesai pipa, maka `ctx.prev.result` mewakili hasil evaluasi tersebut dan tersedia untuk fungsi pertama dalam pipeline.
Jika operasi sebelumnya adalah fungsi pertama, maka `ctx.prev.result` merupakan hasil evaluasi dari handler respons fungsi pertama dan tersedia untuk fungsi kedua dalam pipeline.
Jika operasi sebelumnya adalah fungsi terakhir, maka `ctx.prev.result` mewakili hasil evaluasi dari fungsi terakhir dan tersedia untuk pengendali respons penyelesai pipa.
** `info` **
Objek yang berisi informasi tentang permintaan GraphQL. Untuk struktur bidang ini, lihat [Info](#aws-appsync-resolver-context-reference-info-js).
### Identitas
`identity`Bagian ini berisi informasi tentang penelepon. Bentuk bagian ini tergantung pada jenis otorisasi AWS AppSync API Anda.
Untuk informasi selengkapnya tentang opsi AWS AppSync keamanan, lihat [Otorisasi dan otentikasi](security-authz.md#aws-appsync-security).
** `API_KEY`otorisasi**
`identity`Bidang tidak dihuni.
**`AWS_LAMBDA`otorisasi**
Ini `identity` memiliki bentuk sebagai berikut:
```
type AppSyncIdentityLambda = {
resolverContext: any;
};
```
Berisi `resolverContext` kunci, `identity` berisi `resolverContext` konten yang sama yang dikembalikan oleh fungsi Lambda yang mengotorisasi permintaan.
** `AWS_IAM`otorisasi**
Ini `identity` memiliki bentuk sebagai berikut:
```
type AppSyncIdentityIAM = {
accountId: string;
cognitoIdentityPoolId: string;
cognitoIdentityId: string;
sourceIp: string[];
username: string;
userArn: string;
cognitoIdentityAuthType: string;
cognitoIdentityAuthProvider: string;
};
```
** `AMAZON_COGNITO_USER_POOLS`otorisasi**
Ini `identity` memiliki bentuk sebagai berikut:
```
type AppSyncIdentityCognito = {
sourceIp: string[];
username: string;
groups: string[] | null;
sub: string;
issuer: string;
claims: any;
defaultAuthStrategy: string;
};
```
Setiap bidang didefinisikan sebagai berikut:
** `accountId` **
ID AWS akun penelepon.
** `claims` **
Klaim yang dimiliki pengguna.
** `cognitoIdentityAuthType` **
Entah diautentikasi atau tidak diautentikasi berdasarkan tipe identitas.
** `cognitoIdentityAuthProvider` **
Daftar informasi penyedia identitas eksternal yang dipisahkan koma yang digunakan dalam memperoleh kredensil yang digunakan untuk menandatangani permintaan.
** `cognitoIdentityId` **
ID identitas Amazon Cognito dari penelepon.
** `cognitoIdentityPoolId` **
ID kumpulan identitas Amazon Cognito yang terkait dengan pemanggil.
** `defaultAuthStrategy` **
Strategi otorisasi default untuk penelepon ini (`ALLOW`atau`DENY`).
** `issuer` **
Penerbit token.
** `sourceIp` **
Alamat IP sumber penelepon yang AWS AppSync menerima. Jika permintaan tidak menyertakan `x-forwarded-for` header, nilai IP sumber hanya berisi satu alamat IP dari koneksi TCP. Jika permintaan menyertakan `x-forwarded-for` header, IP sumber adalah daftar alamat IP dari `x-forwarded-for` header, selain alamat IP dari koneksi TCP.
** `sub` **
UUID dari pengguna yang diautentikasi.
** `user` **
Pengguna IAM.
** `userArn` **
Nama Sumber Daya Amazon (ARN) dari pengguna IAM.
** `username` **
Nama pengguna dari pengguna yang diautentikasi. Dalam hal `AMAZON_COGNITO_USER_POOLS` otorisasi, nilai *nama pengguna adalah nilai atribut *cognito:username**. Dalam hal `AWS_IAM` otorisasi, nilai nama *pengguna* adalah nilai prinsipal AWS pengguna. Jika Anda menggunakan otorisasi IAM dengan kredensil yang dijual dari kumpulan identitas Amazon Cognito, kami sarankan Anda menggunakannya. `cognitoIdentityId`
### Akses header permintaan
AWS AppSync mendukung meneruskan header khusus dari klien dan mengaksesnya di resolver GraphQL Anda dengan menggunakan. `ctx.request.headers` Anda kemudian dapat menggunakan nilai header untuk tindakan seperti memasukkan data ke sumber data atau pemeriksaan otorisasi. Anda dapat menggunakan header permintaan tunggal atau beberapa menggunakan `$curl` kunci API dari baris perintah, seperti yang ditunjukkan pada contoh berikut:
**Contoh header tunggal**
Misalkan Anda menetapkan header `custom` dengan nilai `nadia` seperti berikut:
```
curl -XPOST -H "Content-Type:application/graphql" -H "custom:nadia" -H "x-api-key:" -d '{"query":"mutation { createEvent(name: \"demo\", when: \"Next Friday!\", where: \"Here!\") {id name when where description}}"}' https:///graphql
```
Ini kemudian dapat diakses dengan`ctx.request.headers.custom`. Misalnya, mungkin dalam kode berikut untuk DynamoDB:
```
"custom": util.dynamodb.toDynamoDB(ctx.request.headers.custom)
```
**Beberapa contoh header**
Anda juga dapat meneruskan beberapa header dalam satu permintaan dan mengaksesnya di penangan resolver. Misalnya, jika `custom` header diatur dengan dua nilai:
```
curl -XPOST -H "Content-Type:application/graphql" -H "custom:bailey" -H "custom:nadia" -H "x-api-key:" -d '{"query":"mutation { createEvent(name: \"demo\", when: \"Next Friday!\", where: \"Here!\") {id name when where description}}"}' https:///graphql
```
Anda kemudian dapat mengakses ini sebagai array, seperti`ctx.request.headers.custom[1]`.
**catatan**
AWS AppSync tidak mengekspos header cookie di`ctx.request.headers`.
### Mengakses permintaan nama domain kustom
AWS AppSync mendukung konfigurasi domain kustom yang dapat Anda gunakan untuk mengakses GraphQL Anda dan titik akhir real-time untuk Anda. APIs Saat membuat permintaan dengan nama domain khusus, Anda bisa mendapatkan nama domain menggunakan`ctx.request.domainName`.
Saat menggunakan nama domain titik akhir GraphQL default, nilainya adalah. `null`
### Info
`info`Bagian ini berisi informasi tentang permintaan GraphQL. Bagian ini memiliki bentuk sebagai berikut:
```
type Info = {
fieldName: string;
parentTypeName: string;
variables: any;
selectionSetList: string[];
selectionSetGraphQL: string;
};
```
Setiap bidang didefinisikan sebagai berikut:
** `fieldName` **
Nama bidang yang saat ini sedang diselesaikan.
** `parentTypeName` **
Nama tipe induk untuk bidang yang saat ini sedang diselesaikan.
** `variables` **
Peta yang menampung semua variabel yang diteruskan ke permintaan GraphQL.
** `selectionSetList` **
Sebuah daftar representasi bidang dalam set pilihan GraphQL. Bidang yang dialias hanya direferensikan dengan nama alias, bukan nama bidang. Contoh berikut menunjukkan ini secara rinci.
** `selectionSetGraphQL` **
Sebuah representasi string dari set seleksi, diformat sebagai GraphQL skema definisi bahasa (SDL). Meskipun fragmen tidak digabungkan ke dalam kumpulan seleksi, fragmen sebaris dipertahankan, seperti yang ditunjukkan pada contoh berikut.
**catatan**
`JSON.stringify`tidak akan menyertakan `selectionSetGraphQL` dan `selectionSetList` dalam serialisasi string. Anda harus mereferensikan properti ini secara langsung.
Misalnya, jika Anda menyelesaikan `getPost` bidang kueri berikut:
```
query {
getPost(id: $postId) {
postId
title
secondTitle: title
content
author(id: $authorId) {
authorId
name
}
secondAuthor(id: "789") {
authorId
}
... on Post {
inlineFrag: comments: {
id
}
}
... postFrag
}
}
fragment postFrag on Post {
postFrag: comments: {
id
}
}
```
Kemudian `ctx.info` variabel lengkap yang tersedia saat memproses handler mungkin:
```
{
"fieldName": "getPost",
"parentTypeName": "Query",
"variables": {
"postId": "123",
"authorId": "456"
},
"selectionSetList": [
"postId",
"title",
"secondTitle"
"content",
"author",
"author/authorId",
"author/name",
"secondAuthor",
"secondAuthor/authorId",
"inlineFragComments",
"inlineFragComments/id",
"postFragComments",
"postFragComments/id"
],
"selectionSetGraphQL": "{\n getPost(id: $postId) {\n postId\n title\n secondTitle: title\n content\n author(id: $authorId) {\n authorId\n name\n }\n secondAuthor(id: \"789\") {\n authorId\n }\n ... on Post {\n inlineFrag: comments {\n id\n }\n }\n ... postFrag\n }\n}"
}
```
`selectionSetList`mengekspos hanya bidang yang termasuk tipe saat ini. Jika tipe saat ini adalah antarmuka atau gabungan, hanya bidang yang dipilih milik antarmuka yang diekspos. Misalnya, diberikan skema berikut:
```
type Query {
node(id: ID!): Node
}
interface Node {
id: ID
}
type Post implements Node {
id: ID
title: String
author: String
}
type Blog implements Node {
id: ID
title: String
category: String
}
```
Dan query berikut:
```
query {
node(id: "post1") {
id
... on Post {
title
}
... on Blog {
title
}
}
}
```
Saat memanggil `ctx.info.selectionSetList` pada resolusi `Query.node` bidang, hanya yang `id` diekspos:
```
"selectionSetList": [
"id"
]
```
# AWS AppSync JavaScript fitur runtime untuk resolver dan fungsi
Lingkungan `APPSYNC_JS` runtime menyediakan fungsionalitas yang mirip dengan [ECMAScript (ES) versi 6.0](https://262.ecma-international.org/6.0/). Ini mendukung subset fitur-fiturnya dan menyediakan beberapa metode tambahan (utilitas) yang bukan bagian dari spesifikasi ES. Topik berikut mencantumkan semua fitur bahasa yang didukung:
+ [Fitur runtime yang didukung](https://docs.aws.amazon.com/appsync/latest/devguide/supported-features.html) - Pelajari lebih lanjut tentang fitur inti yang didukung, objek primitif, objek dan fungsi bawaan, dll.
+ [Utilitas bawaan](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html) - Variabel util berisi metode utilitas umum untuk membantu Anda bekerja dengan data. Kecuali ditentukan lain, semua utilitas menggunakan set karakter UTF-8.
+ [Modul bawaan](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-modules-js.html) - Pelajari lebih lanjut tentang bagaimana modul bawaan dapat membantu menulis JavaScript resolver dan fungsi.
+ [Utilitas runtime](https://docs.aws.amazon.com/appsync/latest/devguide/runtime-utils-js.html) - Pustaka runtime menyediakan utilitas untuk mengontrol atau memodifikasi properti runtime dari resolver dan fungsi Anda.
+ [Pembantu waktu di util.time - Variabel util.time](https://docs.aws.amazon.com/appsync/latest/devguide/time-helpers-in-util-time-js.html) berisi metode datetime untuk membantu menghasilkan stempel waktu, mengonversi antara format datetime, dan mengurai string datetime. Sintaks untuk format datetime didasarkan pada [DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html), yang dapat Anda referensikan untuk dokumentasi lebih lanjut.
+ [DynamoDB helpers di util.dynamodb](https://docs.aws.amazon.com/appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html) - util.dynamodb berisi metode pembantu yang memudahkan untuk menulis dan membaca data ke Amazon DynamoDB, seperti pemetaan dan pemformatan tipe otomatis.
+ [Pembantu HTTP di util.http](https://docs.aws.amazon.com/appsync/latest/devguide/http-helpers-in-utils-http-js.html) - Utilitas util.http menyediakan metode pembantu yang dapat Anda gunakan untuk mengelola parameter permintaan HTTP dan untuk menambahkan header respons.
+ [Pembantu transformasi di util.transform](https://docs.aws.amazon.com/appsync/latest/devguide/transformation-helpers-in-utils-transform-js.html) - util.transform berisi metode pembantu yang membuatnya lebih mudah untuk melakukan operasi kompleks terhadap sumber data.
+ [Pembantu string di util.str - util.str](https://docs.aws.amazon.com/appsync/latest/devguide/str-helpers-in-util-str-js.html) berisi metode untuk membantu operasi String umum.
+ [Ekstensi](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html) - ekstensi berisi serangkaian metode untuk membuat tindakan tambahan dalam resolver Anda.
+ [Pembantu XMLdi util.xml](https://docs.aws.amazon.com/appsync/latest/devguide/xml-helpers-in-util-xml-js.html) - util.xml berisi metode untuk membantu dengan konversi string XHTML.
**catatan**
Saat ini, referensi ini hanya berlaku untuk runtime versi **1.0.0**.
# Fitur runtime yang didukung
Bagian di bawah ini menjelaskan kumpulan fitur yang didukung dari runtime APPSYNC\$1JS.
## Fitur inti
Fitur inti berikut didukung.
------
#### [ Types ]
Jenis berikut didukung:
+ angka
+ tali
+ boolean
+ objek
+ larik
+ fungsi
------
#### [ Operators ]
Operator didukung, termasuk:
+ operator matematika standar (`+`,`-`,`/`,`%`,`*`, dll.)
+ operator penggabungan nullish () `??`
+ Rantai opsional () `?.`
+ operator bitwise
+ `void`dan `typeof` operator
+ operator penyebaran (`...`)
Operator berikut tidak didukung:
+ operator unary (`++`,`--`, dan`~`)
+ Operator `in`
**catatan**
Gunakan `Object.hasOwn` operator untuk memeriksa apakah properti yang ditentukan ada di objek yang ditentukan.
------
#### [ Statements ]
Pernyataan berikut didukung:
+ `const`
+ `let`
+ `var`
+ `break`
+ `else`
+ `for-in`
+ `for-of`
+ `if`
+ `return`
+ `switch`
+ sintaks spread
Berikut ini tidak didukung:
+ `catch`
+ `continue`
+ `do-while`
+ `finally`
+ `for(initialization; condition; afterthought)`
**catatan**
Pengecualian adalah `for-in` dan `for-of` ekspresi, yang didukung.
+ `throw`
+ `try`
+ `while`
+ pernyataan berlabel
------
#### [ Literals ]
[Literal template](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals) ES 6 berikut didukung:
+ String multi-baris
+ Interpolasi ekspresi
+ Template bersarang
------
#### [ Functions ]
Sintaks fungsi berikut didukung:
+ Deklarasi fungsi didukung.
+ Fungsi panah ES 6 didukung.
+ ES 6 sisanya sintaks parameter didukung.
------
#### [ Strict mode ]
Fungsi beroperasi dalam mode ketat secara default, sehingga Anda tidak perlu menambahkan pernyataan `use_strict` dalam kode fungsi Anda. Ini tidak dapat diubah.
------
## Objek primitif
Objek primitif ES berikut dan fungsinya didukung.
------
#### [ Object ]
Objek berikut didukung:
+ `Object.assign()`
+ `Object.entries()`
+ `Object.hasOwn()`
+ `Object.keys()`
+ `Object.values()`
+ `delete`
------
#### [ String ]
String berikut didukung:
+ `String.prototype.length()`
+ `String.prototype.charAt()`
+ `String.prototype.concat()`
+ `String.prototype.endsWith()`
+ `String.prototype.indexOf()`
+ `String.prototype.lastIndexOf()`
+ `String.raw()`
+ `String.prototype.replace()`
**catatan**
Ekspresi reguler tidak didukung.
Namun, konstruksi ekspresi reguler bergaya Java didukung dalam parameter yang disediakan. Untuk informasi lebih lanjut lihat [Pola](https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html).
+ `String.prototype.replaceAll()`
**catatan**
Ekspresi reguler tidak didukung.
Namun, konstruksi ekspresi reguler bergaya Java didukung dalam parameter yang disediakan. Untuk informasi lebih lanjut lihat [Pola](https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html).
+ `String.prototype.slice()`
+ `String.prototype.split()`
+ `String.prototype.startsWith()`
+ `String.prototype.toLowerCase()`
+ `String.prototype.toUpperCase()`
+ `String.prototype.trim()`
+ `String.prototype.trimEnd()`
+ `String.prototype.trimStart()`
------
#### [ Number ]
Angka-angka berikut didukung:
+ `Number.isFinite`
+ `Number.isNaN`
------
## Objek dan fungsi bawaan
Fungsi dan objek berikut didukung.
------
#### [ Math ]
Fungsi matematika berikut didukung:
+ `Math.random()`
+ `Math.min()`
+ `Math.max()`
+ `Math.round()`
+ `Math.floor()`
+ `Math.ceil()`
------
#### [ Array ]
Metode array berikut didukung:
+ `Array.prototype.length`
+ `Array.prototype.concat()`
+ `Array.prototype.fill()`
+ `Array.prototype.flat()`
+ `Array.prototype.indexOf()`
+ `Array.prototype.join()`
+ `Array.prototype.lastIndexOf()`
+ `Array.prototype.pop()`
+ `Array.prototype.push()`
+ `Array.prototype.reverse()`
+ `Array.prototype.shift()`
+ `Array.prototype.slice()`
+ `Array.prototype.sort()`
**catatan**
`Array.prototype.sort()`tidak mendukung argumen.
+ `Array.prototype.splice()`
+ `Array.prototype.unshift()`
+ `Array.prototype.forEach()`
+ `Array.prototype.map()`
+ `Array.prototype.flatMap()`
+ `Array.prototype.filter()`
+ `Array.prototype.reduce()`
+ `Array.prototype.reduceRight()`
+ `Array.prototype.find()`
+ `Array.prototype.some()`
+ `Array.prototype.every()`
+ `Array.prototype.findIndex()`
+ `Array.prototype.findLast()`
+ `Array.prototype.findLastIndex()`
+ `delete`
------
#### [ Console ]
Objek konsol tersedia untuk debugging. Selama eksekusi kueri langsung, log/error pernyataan konsol dikirim ke Amazon CloudWatch Logs (jika logging diaktifkan). Selama evaluasi kode dengan`evaluateCode`, pernyataan log dikembalikan dalam respons perintah.
+ `console.error()`
+ `console.log()`
------
#### [ Function ]
+ `call`Metode `apply``bind`,, dan tidak didukung.
+ Tidak mendukung konstruktor fungsi.
+ Melewati fungsi sebagai argumen tidak didukung.
+ Panggilan fungsi rekursif tidak didukung.
------
#### [ JSON ]
Metode JSON berikut didukung:
+ `JSON.parse()`
**catatan**
Mengembalikan string kosong jika string diurai tidak valid JSON.
+ `JSON.stringify()`
------
#### [ Promises ]
Proses asinkron tidak didukung, dan janji tidak didukung.
**catatan**
Akses jaringan dan sistem file tidak didukung dalam `APPSYNC_JS` runtime di AWS AppSync. AWS AppSync menangani semua operasi I/O berdasarkan permintaan yang dibuat oleh AWS AppSync resolver atau fungsi. AWS AppSync
------
## Global
Mendukung konstanta global berikut:
+ `NaN`
+ `Infinity`
+ `undefined`
+ [https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html)
+ [https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html)
+ `runtime`
## Jenis kesalahan
Melempar kesalahan dengan `throw` tidak didukung. Anda dapat mengembalikan kesalahan dengan menggunakan `util.error()` fungsi. Anda dapat menyertakan kesalahan dalam respons GraphQL Anda dengan menggunakan fungsi tersebut. `util.appendError`
Untuk informasi selengkapnya, lihat [Kesalahan utils.](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html#utility-helpers-in-error-js)
# Utilitas bawaan
`util`Variabel berisi metode utilitas umum untuk membantu Anda bekerja dengan data. Kecuali ditentukan lain, semua utilitas menggunakan set karakter UTF-8.
## Pengkodean utilitas
### Pengkodean daftar utilitas
**`util.urlEncode(String)`**
Mengembalikan string masukan sebagai string `application/x-www-form-urlencoded` dikodekan.
**`util.urlDecode(String)`**
Mendekode string yang `application/x-www-form-urlencoded` dikodekan kembali ke bentuk yang tidak dikodekan.
**`util.base64Encode(string) : string`**
Mengkodekan input ke dalam string yang dikodekan base64.
**`util.base64Decode(string) : string`**
Mendekode data dari string yang dikodekan base64.
## Utilitas pembuatan ID
### Daftar utilitas pembuatan ID
**`util.autoId()`**
Mengembalikan UUID 128-bit yang dihasilkan secara acak.
**`util.autoUlid()`**
Mengembalikan ULID 128-bit yang dihasilkan secara acak (Universalally Unique Lexicographically Sortable Identifier).
**`util.autoKsuid()`**
Mengembalikan 128-bit yang dihasilkan secara acak KSUID (K-Sortable Unique Identifier) base62 dikodekan sebagai String dengan panjang 27.
## Kesalahan utils
### Daftar utilitas kesalahan
**`util.error(String, String?, Object?, Object?)`**
Melempar kesalahan khusus. Ini dapat digunakan dalam template pemetaan permintaan atau respons jika template mendeteksi kesalahan dengan permintaan atau dengan hasil pemanggilan. Selain itu, `errorType` bidang, `data` bidang, dan `errorInfo` bidang dapat ditentukan. `data`Nilai akan ditambahkan ke `error` blok yang sesuai di `errors` dalam respons GraphQL.
`data`akan disaring berdasarkan set pemilihan kueri. `errorInfo`Nilai akan ditambahkan ke `error` blok yang sesuai di `errors` dalam respons GraphQL.
`errorInfo`**tidak** akan disaring berdasarkan set pemilihan kueri.
**`util.appendError(String, String?, Object?, Object?)`**
Menambahkan kesalahan kustom. Ini dapat digunakan dalam template pemetaan permintaan atau respons jika template mendeteksi kesalahan dengan permintaan atau dengan hasil pemanggilan. Selain itu, `errorType` bidang, `data` bidang, dan `errorInfo` bidang dapat ditentukan. Tidak seperti`util.error(String, String?, Object?, Object?)`, evaluasi template tidak akan terganggu, sehingga data dapat dikembalikan ke penelepon. `data`Nilai akan ditambahkan ke `error` blok yang sesuai di `errors` dalam respons GraphQL.
`data`akan disaring berdasarkan set pemilihan kueri. `errorInfo`Nilai akan ditambahkan ke `error` blok yang sesuai di `errors` dalam respons GraphQL.
`errorInfo`**tidak** akan disaring berdasarkan set pemilihan kueri.
## Utils pencocokan jenis dan pola
### Jenis dan pola pencocokan daftar utilitas
**`util.matches(String, String) : Boolean`**
Mengembalikan nilai true jika pola tertentu dalam argumen pertama cocok dengan data yang disediakan dalam argumen kedua. Pola harus berupa ekspresi reguler seperti`util.matches("a*b", "aaaaab")`. Fungsionalitas ini didasarkan pada [Pola](https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html), yang dapat Anda referensi untuk dokumentasi lebih lanjut.
**`util.authType()`**
Mengembalikan String yang menjelaskan jenis multi-auth yang digunakan oleh permintaan, mengembalikan “IAM Authorization”, “User Pool Authorization”, “Open ID Connect Authorization”, atau “API Key Authorization”.
## Kembalikan utilitas perilaku nilai
### Kembalikan daftar utilitas perilaku nilai
**`util.escapeJavaScript(String)`**
Mengembalikan string masukan sebagai string JavaScript lolos.
## Utils otorisasi penyelesai
### Daftar utilitas otorisasi penyelesai
**`util.unauthorized()`**
Melempar `Unauthorized` untuk bidang yang sedang diselesaikan. Gunakan ini dalam templat pemetaan permintaan atau respons untuk menentukan apakah akan mengizinkan pemanggil menyelesaikan bidang.
# Modul bawaan
Modul adalah bagian dari `APPSYNC_JS` runtime dan menyediakan utilitas untuk membantu menulis JavaScript resolver dan fungsi. Untuk sampel dan contoh, lihat [aws-appsync-resolver-samples](https://github.com/aws-samples/aws-appsync-resolver-samples) GitHub repositori.
## Fungsi modul DynamoDB
Fungsi modul DynamoDB memberikan pengalaman yang ditingkatkan saat berinteraksi dengan sumber data DynamoDB. Anda dapat membuat permintaan terhadap sumber data DynamoDB Anda menggunakan fungsi dan tanpa menambahkan pemetaan tipe.
Modul diimpor menggunakan`@aws-appsync/utils/dynamodb`:
```
// Modules are imported using @aws-appsync/utils/dynamodb
import * as ddb from '@aws-appsync/utils/dynamodb';
```
### Fungsi
#### Daftar fungsi
**` get(payload: GetInput): DynamoDBGetItemRequest`**
Lihat [Masukan](#built-in-ddb-modules-inputs) untuk informasi tentang GetInput.
Menghasilkan `DynamoDBGetItemRequest` objek untuk membuat [GetItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-getitem)permintaan ke DynamoDB.
```
import { get } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
return get({ key: { id: ctx.args.id } });
}
```
**`put(payload): DynamoDBPutItemRequest`**
Menghasilkan `DynamoDBPutItemRequest` objek untuk membuat [PutItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem)permintaan ke DynamoDB.
```
import * as ddb from '@aws-appsync/utils/dynamodb'
export function request(ctx) {
return ddb.put({ key: { id: util.autoId() }, item: ctx.args });
}
```
**`remove(payload): DynamoDBDeleteItemRequest`**
Menghasilkan `DynamoDBDeleteItemRequest` objek untuk membuat [DeleteItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-deleteitem)permintaan ke DynamoDB.
```
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
return ddb.remove({ key: { id: ctx.args.id } });
}
```
**`scan(payload): DynamoDBScanRequest`**
Menghasilkan permintaan `DynamoDBScanRequest` untuk membuat [Scan](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan) ke DynamoDB.
```
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const { limit = 10, nextToken } = ctx.args;
return ddb.scan({ limit, nextToken });
}
```
**`sync(payload): DynamoDBSyncRequest`**
Menghasilkan `DynamoDBSyncRequest` objek untuk membuat permintaan [Sync](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-sync). Permintaan hanya menerima data yang diubah sejak kueri terakhir (pembaruan delta). Permintaan hanya dapat dibuat ke sumber data DynamoDB berversi.
```
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const { limit = 10, nextToken, lastSync } = ctx.args;
return ddb.sync({ limit, nextToken, lastSync });
}
```
**`update(payload): DynamoDBUpdateItemRequest`**
Menghasilkan `DynamoDBUpdateItemRequest` objek untuk membuat [UpdateItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-updateitem)permintaan ke DynamoDB.
### Operasi
Pembantu operasi memungkinkan Anda untuk mengambil tindakan spesifik pada bagian data Anda selama pembaruan. Untuk memulai, impor `operations` dari`@aws-appsync/utils/dynamodb`:
```
// Modules are imported using operations
import {operations} from '@aws-appsync/utils/dynamodb';
```
#### Daftar operasi
**`add(payload)`**
Fungsi pembantu yang menambahkan item atribut baru saat memperbarui DynamoDB.
**Contoh**
Untuk menambahkan alamat (jalan, kota, dan kode pos) ke item DynamoDB yang ada menggunakan nilai ID:
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const updateObj = {
address: operations.add({
street1: '123 Main St',
city: 'New York',
zip: '10001',
}),
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`append (payload)`**
Fungsi pembantu yang menambahkan payload ke daftar yang ada di DynamoDB.
**Contoh**
Untuk menambahkan friend IDs (`newFriendIds`) yang baru ditambahkan ke daftar teman yang ada (`friendsIds`) selama pembaruan:
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const newFriendIds = [101, 104, 111];
const updateObj = {
friendsIds: operations.append(newFriendIds),
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`decrement (by?)`**
Fungsi pembantu yang mengurangi nilai atribut yang ada di item saat memperbarui DynamoDB.
**Contoh**
Untuk mengurangi counter teman (`friendsCount`) sebesar 10:
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const updateObj = {
friendsCount: operations.decrement(10),
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`increment (by?)`**
Fungsi pembantu yang menambah nilai atribut yang ada di item saat memperbarui DynamoDB.
**Contoh**
Untuk menambah counter teman (`friendsCount`) sebesar 10:
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const updateObj = {
friendsCount: operations.increment(10),
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`prepend (payload)`**
Fungsi pembantu yang ditambahkan ke daftar yang ada di DynamoDB.
**Contoh**
Untuk menambahkan friend IDs (`newFriendIds`) yang baru ditambahkan ke daftar teman yang ada (`friendsIds`) selama pembaruan:
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const newFriendIds = [101, 104, 111];
const updateObj = {
friendsIds: operations.prepend(newFriendIds),
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`replace (payload)`**
Fungsi pembantu yang menggantikan atribut yang ada saat memperbarui item di DynamoDB. Ini berguna ketika Anda ingin memperbarui seluruh objek atau subobject di atribut dan bukan hanya kunci di payload.
**Contoh**
Untuk mengganti alamat (jalan, kota, dan kode pos) dalam suatu `info` objek:
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const updateObj = {
info: {
address: operations.replace({
street1: '123 Main St',
city: 'New York',
zip: '10001',
}),
},
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`updateListItem (payload, index)`**
Fungsi pembantu yang menggantikan item dalam daftar.
**Contoh**
Dalam lingkup update (`newFriendIds`), contoh ini digunakan `updateListItem` untuk memperbarui nilai ID dari item kedua (index:`1`, new ID:`102`) dan item ketiga (index:`2`, new ID:`112`) dalam list (`friendsIds`).
```
import { update, operations as ops } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const newFriendIds = [
ops.updateListItem('102', 1), ops.updateListItem('112', 2)
];
const updateObj = { friendsIds: newFriendIds };
return update({ key: { id: 1 }, update: updateObj });
}
```
### Masukan
#### Daftar masukan
**`Type GetInput`**
```
GetInput: {
consistentRead?: boolean;
key: DynamoDBKey;
}
```
**Jenis Deklarasi**
+ `consistentRead?: boolean` (opsional)
Boolean opsional untuk menentukan apakah Anda ingin melakukan pembacaan yang sangat konsisten dengan DynamoDB.
+ `key: DynamoDBKey`(Diperlukan)
Parameter yang diperlukan yang menentukan kunci item di DynamoDB. Item DynamoDB mungkin memiliki kunci hash tunggal atau kunci hash dan sortir.
**`Type PutInput`**
```
PutInput: {
_version?: number;
condition?: DynamoDBFilterObject | null;
customPartitionKey?: string;
item: Partial;
key: DynamoDBKey;
populateIndexFields?: boolean;
}
```
**Jenis Deklarasi**
+ `_version?: number` (opsional)
+ `condition?: DynamoDBFilterObject | null` (opsional)
Ketika Anda meletakkan objek dalam tabel DynamoDB, Anda dapat secara opsional menentukan ekspresi kondisional yang mengontrol apakah permintaan harus berhasil atau tidak berdasarkan status objek yang sudah ada di DynamoDB sebelum operasi dilakukan.
+ `customPartitionKey?: string` (opsional)
Saat diaktifkan, nilai string ini memodifikasi format `ds_sk` dan `ds_pk` catatan yang digunakan oleh tabel sinkronisasi delta saat pembuatan versi telah diaktifkan. Saat diaktifkan, pemrosesan `populateIndexFields` entri juga diaktifkan.
+ `item: Partial`(Diperlukan)
Sisa atribut item yang akan ditempatkan ke DynamoDB.
+ `key: DynamoDBKey`(Diperlukan)
Parameter yang diperlukan yang menentukan kunci item di DynamoDB di mana put akan dilakukan. Item DynamoDB mungkin memiliki kunci hash tunggal atau kunci hash dan sortir.
+ `populateIndexFields?: boolean` (opsional)
Nilai boolean yang, ketika diaktifkan bersama dengan`customPartitionKey`, membuat entri baru untuk setiap catatan dalam tabel sinkronisasi delta, khususnya di kolom dan`gsi_ds_pk`. `gsi_ds_sk` Untuk informasi selengkapnya, lihat [Deteksi dan sinkronisasi konflik](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) di *Panduan AWS AppSync Pengembang*.
**`Type QueryInput`**
```
QueryInput: ScanInput & {
query: DynamoDBKeyCondition>;
}
```
**Jenis Deklarasi**
+ `query: DynamoDBKeyCondition>`(Diperlukan)
Menentukan kondisi kunci yang menjelaskan item untuk query. Untuk indeks tertentu, kondisi untuk kunci partisi harus berupa persamaan dan kunci pengurutan perbandingan atau a `beginsWith` (ketika itu adalah string). Hanya tipe angka dan string yang didukung untuk kunci partisi dan sortir.
**Contoh**
Ambil `User` tipe di bawah ini:
```
type User = {
id: string;
name: string;
age: number;
isVerified: boolean;
friendsIds: string[]
}
```
Kueri hanya dapat menyertakan bidang-bidang berikut:`id`,`name`, dan`age`:
```
const query: QueryInput = {
name: { eq: 'John' },
age: { gt: 20 },
}
```
**`Type RemoveInput`**
```
RemoveInput: {
_version?: number;
condition?: DynamoDBFilterObject;
customPartitionKey?: string;
key: DynamoDBKey;
populateIndexFields?: boolean;
}
```
**Jenis Deklarasi**
+ `_version?: number` (opsional)
+ `condition?: DynamoDBFilterObject` (opsional)
Saat Anda menghapus objek di DynamoDB, Anda dapat secara opsional menentukan ekspresi bersyarat yang mengontrol apakah permintaan harus berhasil atau tidak berdasarkan status objek yang sudah ada di DynamoDB sebelum operasi dilakukan.
**Contoh**
Contoh berikut adalah `DeleteItem` ekspresi yang berisi kondisi yang memungkinkan operasi berhasil hanya jika pemilik dokumen cocok dengan pengguna yang membuat permintaan.
```
type Task = {
id: string;
title: string;
description: string;
owner: string;
isComplete: boolean;
}
const condition: DynamoDBFilterObject = {
owner: { eq: 'XXXXXXXXXXXXXXXX' },
}
remove({
key: {
id: 'XXXXXXXXXXXXXXXX',
},
condition,
});
```
+ `customPartitionKey?: string` (opsional)
Saat diaktifkan, `customPartitionKey` nilai mengubah format `ds_sk` dan `ds_pk` catatan yang digunakan oleh tabel sinkronisasi delta saat pembuatan versi telah diaktifkan. Saat diaktifkan, pemrosesan `populateIndexFields` entri juga diaktifkan.
+ `key: DynamoDBKey`(Diperlukan)
Parameter yang diperlukan yang menentukan kunci item di DynamoDB yang sedang dihapus. Item DynamoDB mungkin memiliki kunci hash tunggal atau kunci hash dan sortir.
**Contoh**
Jika `User` hanya memiliki kunci hash dengan pengguna`id`, maka kuncinya akan terlihat seperti ini:
```
type User = {
id: number
name: string
age: number
isVerified: boolean
}
const key: DynamoDBKey = {
id: 1,
}
```
Jika pengguna tabel memiliki kunci hash (`id`) dan sort key (`name`), maka kuncinya akan terlihat seperti ini:
```
type User = {
id: number
name: string
age: number
isVerified: boolean
friendsIds: string[]
}
const key: DynamoDBKey = {
id: 1,
name: 'XXXXXXXXXX',
}
```
+ `populateIndexFields?: boolean` (opsional)
Nilai boolean yang, ketika diaktifkan bersama dengan`customPartitionKey`, membuat entri baru untuk setiap catatan dalam tabel sinkronisasi delta, khususnya di kolom dan`gsi_ds_pk`. `gsi_ds_sk`
**`Type ScanInput`**
```
ScanInput: {
consistentRead?: boolean | null;
filter?: DynamoDBFilterObject | null;
index?: string | null;
limit?: number | null;
nextToken?: string | null;
scanIndexForward?: boolean | null;
segment?: number;
select?: DynamoDBSelectAttributes;
totalSegments?: number;
}
```
**Jenis Deklarasi**
+ `consistentRead?: boolean | null` (opsional)
Boolean opsional untuk menunjukkan pembacaan yang konsisten saat menanyakan DynamoDB. Nilai default-nya adalah `false`.
+ `filter?: DynamoDBFilterObject | null` (opsional)
Filter opsional untuk diterapkan pada hasil setelah mengambilnya dari tabel.
+ `index?: string | null` (opsional)
Nama opsional indeks untuk memindai.
+ `limit?: number | null` (opsional)
Jumlah maksimal hasil opsional untuk dikembalikan.
+ `nextToken?: string | null` (opsional)
Token pagination opsional untuk melanjutkan kueri sebelumnya. Ini akan diperoleh dari kueri sebelumnya.
+ `scanIndexForward?: boolean | null` (opsional)
Boolean opsional untuk menunjukkan apakah kueri dilakukan dalam urutan naik atau turun. Secara default, nilai ini diatur ke `true`.
+ `segment?: number` (opsional)
+ `select?: DynamoDBSelectAttributes` (opsional)
Atribut untuk kembali dari DynamoDB. Secara default, AWS AppSync DynamoDB resolver hanya mengembalikan atribut yang diproyeksikan ke dalam indeks. Nilai yang didukung adalah:
+ `ALL_ATTRIBUTES`
Mengembalikan semua atribut item dari tabel tertentu atau indeks. Jika Anda menanyakan indeks sekunder lokal, DynamoDB mengambil seluruh item dari tabel induk untuk setiap item yang cocok dalam indeks. Jika indeks dikonfigurasi untuk memproyeksikan semua atribut item, semua data dapat diperoleh dari indeks sekunder lokal dan tidak diperlukan pengambilan.
+ `ALL_PROJECTED_ATTRIBUTES`
Mengembalikan semua atribut yang telah diproyeksikan ke dalam indeks. Jika indeks dikonfigurasi untuk memproyeksikan semua atribut, nilai pengembalian ini setara dengan menentukan`ALL_ATTRIBUTES`.
+ `SPECIFIC_ATTRIBUTES`
Mengembalikan hanya atribut yang tercantum dalam`ProjectionExpression`. Nilai pengembalian ini setara dengan menentukan `ProjectionExpression` tanpa menentukan nilai apa pun untuk. `AttributesToGet`
+ `totalSegments?: number` (opsional)
**`Type DynamoDBSyncInput`**
```
DynamoDBSyncInput: {
basePartitionKey?: string;
deltaIndexName?: string;
filter?: DynamoDBFilterObject | null;
lastSync?: number;
limit?: number | null;
nextToken?: string | null;
}
```
**Jenis Deklarasi**
+ `basePartitionKey?: string` (opsional)
Kunci partisi dari tabel dasar yang akan digunakan saat melakukan operasi Sync. Bidang ini memungkinkan operasi Sync dilakukan ketika tabel menggunakan kunci partisi kustom.
+ `deltaIndexName?: string` (opsional)
Indeks yang digunakan untuk operasi Sync. Indeks ini diperlukan untuk mengaktifkan operasi Sinkronisasi di seluruh tabel penyimpanan delta saat tabel menggunakan kunci partisi khusus. Operasi Sinkronisasi akan dilakukan pada GSI (dibuat pada `gsi_ds_pk` dan`gsi_ds_sk`).
+ `filter?: DynamoDBFilterObject | null` (opsional)
Filter opsional untuk diterapkan pada hasil setelah mengambilnya dari tabel.
+ `lastSync?: number` (opsional)
Saat itu, dalam milidetik epoch, di mana operasi Sync sukses terakhir dimulai. Jika ditentukan, hanya item yang telah berubah setelah `lastSync` dikembalikan. Bidang ini seharusnya hanya diisi setelah mengambil semua halaman dari operasi Sinkronisasi awal. Jika dihilangkan, hasil dari tabel dasar akan dikembalikan. Jika tidak, hasil dari tabel delta akan dikembalikan.
+ `limit?: number | null` (opsional)
Jumlah maksimum opsional item untuk dievaluasi pada satu waktu. Jika dihilangkan, batas default akan diatur ke `100` item. Nilai maksimum untuk bidang ini adalah `1000` item.
+ `nextToken?: string | null` (opsional)
**`Type DynamoDBUpdateInput`**
```
DynamoDBUpdateInput: {
_version?: number;
condition?: DynamoDBFilterObject;
customPartitionKey?: string;
key: DynamoDBKey;
populateIndexFields?: boolean;
update: DynamoDBUpdateObject;
}
```
**Jenis Deklarasi**
+ `_version?: number` (opsional)
+ `condition?: DynamoDBFilterObject` (opsional)
Saat Anda memperbarui objek di DynamoDB, Anda dapat secara opsional menentukan ekspresi bersyarat yang mengontrol apakah permintaan harus berhasil atau tidak berdasarkan status objek yang sudah ada di DynamoDB sebelum operasi dilakukan.
+ `customPartitionKey?: string` (opsional)
Saat diaktifkan, `customPartitionKey` nilai mengubah format `ds_sk` dan `ds_pk` catatan yang digunakan oleh tabel sinkronisasi delta saat pembuatan versi telah diaktifkan. Saat diaktifkan, pemrosesan `populateIndexFields` entri juga diaktifkan.
+ `key: DynamoDBKey`(Diperlukan)
Parameter yang diperlukan yang menentukan kunci item di DynamoDB yang sedang diperbarui. Item DynamoDB mungkin memiliki kunci hash tunggal atau kunci hash dan sortir.
+ `populateIndexFields?: boolean` (opsional)
Nilai boolean yang, ketika diaktifkan bersama dengan`customPartitionKey`, membuat entri baru untuk setiap catatan dalam tabel sinkronisasi delta, khususnya di kolom dan`gsi_ds_pk`. `gsi_ds_sk`
+ `update: DynamoDBUpdateObject`
Objek yang menentukan atribut yang akan diperbarui bersama dengan nilai-nilai baru untuk mereka. Objek pembaruan dapat digunakan dengan`add`,`remove`,`replace`,`increment`,`decrement`,`append`,`prepend`,`updateListItem`.
## Fungsi modul Amazon RDS
Fungsi modul Amazon RDS memberikan pengalaman yang disempurnakan saat berinteraksi dengan database yang dikonfigurasi dengan Amazon RDS Data API. Modul diimpor menggunakan`@aws-appsync/utils/rds`:
```
import * as rds from '@aws-appsync/utils/rds';
```
Fungsi juga dapat diimpor secara individual. Misalnya, impor di bawah ini menggunakan`sql`:
```
import { sql } from '@aws-appsync/utils/rds';
```
### Fungsi
Anda dapat menggunakan pembantu utilitas modul AWS AppSync RDS untuk berinteraksi dengan database Anda.
#### Pilih
`select`Utilitas membuat `SELECT` pernyataan untuk query database relasional Anda.
**Penggunaan dasar**
Dalam bentuk dasarnya, Anda dapat menentukan tabel yang ingin Anda kueri:
```
import { select, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
// Generates statement:
// "SELECT * FROM "persons"
return createPgStatement(select({table: 'persons'}));
}
```
Perhatikan bahwa Anda juga dapat menentukan skema dalam pengidentifikasi tabel Anda:
```
import { select, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
// Generates statement:
// SELECT * FROM "private"."persons"
return createPgStatement(select({table: 'private.persons'}));
}
```
**Menentukan kolom**
Anda dapat menentukan kolom dengan `columns` properti. Jika ini tidak disetel ke nilai, defaultnya adalah: `*`
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name']
}));
}
```
Anda dapat menentukan tabel kolom juga:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "persons"."name"
// FROM "persons"
return createPgStatement(select({
table: 'persons',
columns: ['id', 'persons.name']
}));
}
```
**Batas dan offset**
Anda dapat menerapkan `limit` dan `offset` ke kueri:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
// LIMIT :limit
// OFFSET :offset
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
limit: 10,
offset: 40
}));
}
```
**Memesan oleh**
Anda dapat mengurutkan hasil Anda dengan `orderBy` properti. Menyediakan array objek yang menentukan kolom dan `dir` properti opsional:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name" FROM "persons"
// ORDER BY "name", "id" DESC
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
orderBy: [{column: 'name'}, {column: 'id', dir: 'DESC'}]
}));
}
```
**Filter**
Anda dapat membangun filter dengan menggunakan objek kondisi khusus:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
// WHERE "name" = :NAME
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
where: {name: {eq: 'Stephane'}}
}));
}
```
Anda juga dapat menggabungkan filter:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
// WHERE "name" = :NAME and "id" > :ID
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
where: {name: {eq: 'Stephane'}, id: {gt: 10}}
}));
}
```
Anda juga dapat membuat `OR` pernyataan:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
// WHERE "name" = :NAME OR "id" > :ID
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
where: { or: [
{ name: { eq: 'Stephane'} },
{ id: { gt: 10 } }
]}
}));
}
```
Anda juga dapat meniadakan suatu kondisi dengan`not`:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
// WHERE NOT ("name" = :NAME AND "id" > :ID)
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
where: { not: [
{ name: { eq: 'Stephane'} },
{ id: { gt: 10 } }
]}
}));
}
```
Anda juga dapat menggunakan operator berikut untuk membandingkan nilai:
|
|
| Operator | Deskripsi | Jenis nilai yang mungkin |
| --- |--- |--- |
| persamaan | Sama | nomor, string, boolean |
| ne | Tidak sama | nomor, string, boolean |
| le | Kurang dari atau sama | nomor, string |
| lt | Kurang dari | nomor, string |
| ge | Lebih besar dari atau sama | nomor, string |
| gt | Lebih besar dari | nomor, string |
| mengandung | Suka | string |
| NotBerisi | Tidak suka | string |
| Mulailah dengan | Dimulai dengan awalan | string |
| antara | Antara dua nilai | nomor, string |
| AttributeExists | Atribut tidak null | nomor, string, boolean |
| ukuran | memeriksa panjang elemen | string |
#### Sisipkan
`insert`Utilitas menyediakan cara mudah untuk memasukkan item baris tunggal dalam database Anda dengan operasi. `INSERT`
**Penyisipan item tunggal**
Untuk menyisipkan item, tentukan tabel dan kemudian masukkan objek nilai Anda. Kunci objek dipetakan ke kolom tabel Anda. Nama kolom secara otomatis lolos, dan nilai dikirim ke database menggunakan peta variabel:
```
import { insert, createMySQLStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
const { input: values } = ctx.args;
const insertStatement = insert({ table: 'persons', values });
// Generates statement:
// INSERT INTO `persons`(`name`)
// VALUES(:NAME)
return createMySQLStatement(insertStatement)
}
```
**Kasus penggunaan MySQL**
Anda dapat menggabungkan `insert` diikuti oleh a `select` untuk mengambil baris yang disisipkan:
```
import { insert, select, createMySQLStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
const { input: values } = ctx.args;
const insertStatement = insert({ table: 'persons', values });
const selectStatement = select({
table: 'persons',
columns: '*',
where: { id: { eq: values.id } },
limit: 1,
});
// Generates statement:
// INSERT INTO `persons`(`name`)
// VALUES(:NAME)
// and
// SELECT *
// FROM `persons`
// WHERE `id` = :ID
return createMySQLStatement(insertStatement, selectStatement)
}
```
**Kasus penggunaan postgres**
Dengan Postgres, Anda dapat menggunakan [https://www.postgresql.org/docs/current/dml-returning.html](https://www.postgresql.org/docs/current/dml-returning.html)untuk mendapatkan data dari baris yang Anda masukkan. Ia menerima `*` atau array nama kolom:
```
import { insert, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
const { input: values } = ctx.args;
const insertStatement = insert({
table: 'persons',
values,
returning: '*'
});
// Generates statement:
// INSERT INTO "persons"("name")
// VALUES(:NAME)
// RETURNING *
return createPgStatement(insertStatement)
}
```
#### Perbarui
`update`Utilitas memungkinkan Anda untuk memperbarui baris yang ada. Anda dapat menggunakan objek kondisi untuk menerapkan perubahan pada kolom yang ditentukan di semua baris yang memenuhi kondisi. Sebagai contoh, katakanlah kita memiliki skema yang memungkinkan kita membuat mutasi ini. Kami ingin memperbarui `name` of `Person` dengan `id` nilai `3` tetapi hanya jika kami mengetahuinya (`known_since`) sejak tahun ini`2000`:
```
mutation Update {
updatePerson(
input: {id: 3, name: "Jon"},
condition: {known_since: {ge: "2000"}}
) {
id
name
}
}
```
Penyelesai pembaruan kami terlihat seperti ini:
```
import { update, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
const { input: { id, ...values }, condition } = ctx.args;
const where = {
...condition,
id: { eq: id },
};
const updateStatement = update({
table: 'persons',
values,
where,
returning: ['id', 'name'],
});
// Generates statement:
// UPDATE "persons"
// SET "name" = :NAME, "birthday" = :BDAY, "country" = :COUNTRY
// WHERE "id" = :ID
// RETURNING "id", "name"
return createPgStatement(updateStatement)
}
```
Kita dapat menambahkan cek ke kondisi kita untuk memastikan bahwa hanya baris yang memiliki kunci utama `id` sama dengan `3` yang diperbarui. Demikian pula, untuk Postgres`inserts`, Anda dapat menggunakan `returning` untuk mengembalikan data yang dimodifikasi.
#### Menghapus
`remove`Utilitas memungkinkan Anda untuk menghapus baris yang ada. Anda dapat menggunakan objek kondisi pada semua baris yang memenuhi kondisi. Perhatikan bahwa itu `delete` adalah kata kunci yang dicadangkan di JavaScript. `remove`harus digunakan sebagai gantinya:
```
import { remove, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
const { input: { id }, condition } = ctx.args;
const where = { ...condition, id: { eq: id } };
const deleteStatement = remove({
table: 'persons',
where,
returning: ['id', 'name'],
});
// Generates statement:
// DELETE "persons"
// WHERE "id" = :ID
// RETURNING "id", "name"
return createPgStatement(updateStatement)
}
```
### Casting
Dalam beberapa kasus, Anda mungkin ingin lebih spesifisitas tentang jenis objek yang benar untuk digunakan dalam pernyataan Anda. Anda dapat menggunakan petunjuk jenis yang disediakan untuk menentukan jenis parameter Anda. AWS AppSync mendukung [petunjuk jenis yang sama](https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_SqlParameter.html#rdsdtataservice-Type-SqlParameter-typeHint) dengan Data API. Anda dapat mentransmisikan parameter Anda dengan menggunakan `typeHint` fungsi dari AWS AppSync `rds` modul.
Contoh berikut memungkinkan Anda untuk mengirim array sebagai nilai yang dicor sebagai objek JSON. Kami menggunakan `->` operator untuk mengambil elemen di `index` `2` dalam array JSON:
```
import { sql, createPgStatement, toJsonObject, typeHint } from '@aws-appsync/utils/rds';
export function request(ctx) {
const arr = ctx.args.list_of_ids
const statement = sql`select ${typeHint.JSON(arr)}->2 as value`
return createPgStatement(statement)
}
export function response(ctx) {
return toJsonObject(ctx.result)[0][0].value
}
```
Casting juga berguna saat menangani dan membandingkan`DATE`,`TIME`, dan`TIMESTAMP`:
```
import { select, createPgStatement, typeHint } from '@aws-appsync/utils/rds';
export function request(ctx) {
const when = ctx.args.when
const statement = select({
table: 'persons',
where: { createdAt : { gt: typeHint.DATETIME(when) } }
})
return createPgStatement(statement)
}
```
Berikut contoh lain yang menunjukkan bagaimana Anda dapat mengirim tanggal dan waktu saat ini:
```
import { sql, createPgStatement, typeHint } from '@aws-appsync/utils/rds';
export function request(ctx) {
const now = util.time.nowFormatted('YYYY-MM-dd HH:mm:ss')
return createPgStatement(sql`select ${typeHint.TIMESTAMP(now)}`)
}
```
**Petunjuk tipe yang tersedia**
+ `typeHint.DATE`- Parameter yang sesuai dikirim sebagai objek `DATE` tipe ke database. Format yang diterima adalah `YYYY-MM-DD`.
+ `typeHint.DECIMAL`- Parameter yang sesuai dikirim sebagai objek `DECIMAL` tipe ke database.
+ `typeHint.JSON`- Parameter yang sesuai dikirim sebagai objek `JSON` tipe ke database.
+ `typeHint.TIME`- Nilai parameter string yang sesuai dikirim sebagai objek dari `TIME` tipe ke database. Format yang diterima adalah `HH:MM:SS[.FFF]`.
+ `typeHint.TIMESTAMP`- Nilai parameter string yang sesuai dikirim sebagai objek dari `TIMESTAMP` tipe ke database. Format yang diterima adalah `YYYY-MM-DD HH:MM:SS[.FFF]`.
+ `typeHint.UUID`- Nilai parameter string yang sesuai dikirim sebagai objek dari `UUID` tipe ke database.
# Utilitas runtime
`runtime`Pustaka menyediakan utilitas untuk mengontrol atau memodifikasi properti runtime dari resolver dan fungsi Anda.
## Daftar utilitas runtime
**`runtime.earlyReturn(obj?: unknown, returnOptions?: {skipTo: 'END' | 'NEXT'}): never`**
Memanggil fungsi ini akan menghentikan eksekusi handler saat ini, AWS AppSync fungsi atau resolver (Unit atau Pipeline Resolver) tergantung pada konteks saat ini. Objek yang ditentukan dikembalikan sebagai hasilnya.
+ Saat dipanggil dalam penangan permintaan AWS AppSync fungsi, sumber data dan penangan respons dilewati, dan penangan permintaan fungsi berikutnya (atau pengendali respons penyelesai pipa jika ini adalah fungsi terakhir) dipanggil. AWS AppSync
+ Ketika dipanggil dalam penangan permintaan penyelesai AWS AppSync pipa, eksekusi pipeline dilewati, dan pengendali respons penyelesai pipa segera dipanggil.
+ Ketika `returnOptions` diberikan dengan `skipTo` disetel ke “END”, eksekusi pipeline dilewati, dan pengendali respons penyelesai pipa segera dipanggil.
+ Ketika `returnOptions` diberikan dengan `skipTo` set ke “NEXT”, eksekusi fungsi dilewati, dan pengendali pipeline berikutnya dipanggil.
**Contoh**
```
import { runtime } from '@aws-appsync/utils'
export function request(ctx) {
runtime.earlyReturn({ hello: 'world' })
// code below is not executed
return ctx.args
}
// never called because request returned early
export function response(ctx) {
return ctx.result
}
```
# Pembantu waktu di util.time
`util.time`Variabel berisi metode datetime untuk membantu menghasilkan stempel waktu, mengonversi antara format datetime, dan mengurai string datetime. Sintaks untuk format datetime didasarkan pada [DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html)mana Anda dapat referensi untuk dokumentasi lebih lanjut.
## Daftar utilitas waktu
**`util.time.nowISO8601()`**
Mengembalikan representasi String dari UTC dalam [ISO8601format](https://en.wikipedia.org/wiki/ISO_8601).
**`util.time.nowEpochSeconds()`**
Mengembalikan jumlah detik dari epoch 1970-01-01T 00:00:00 Z ke sekarang.
**`util.time.nowEpochMilliSeconds()`**
Mengembalikan jumlah milidetik dari epoch 1970-01-01T 00:00:00 Z ke sekarang.
**`util.time.nowFormatted(String)`**
Mengembalikan string timestamp saat ini di UTC menggunakan format yang ditentukan dari tipe input String.
**`util.time.nowFormatted(String, String)`**
Mengembalikan string timestamp saat ini untuk zona waktu menggunakan format yang ditentukan dan zona waktu dari jenis input String.
**`util.time.parseFormattedToEpochMilliSeconds(String, String)`**
Mem-parsing stempel waktu yang diteruskan sebagai String bersama dengan format yang berisi zona waktu, lalu mengembalikan stempel waktu sebagai milidetik sejak epoch.
**`util.time.parseFormattedToEpochMilliSeconds(String, String, String)`**
Mem-parsing stempel waktu yang diteruskan sebagai String bersama dengan format dan zona waktu, lalu mengembalikan stempel waktu sebagai milidetik sejak epoch.
**`util.time.parseISO8601ToEpochMilliSeconds(String)`**
Mem-parsing ISO8601 stempel waktu yang diteruskan sebagai String, lalu mengembalikan stempel waktu sebagai milidetik sejak epoch.
**`util.time.epochMilliSecondsToSeconds(long)`**
Mengonversi stempel waktu milidetik epoch menjadi stempel waktu epoch detik.
**`util.time.epochMilliSecondsToISO8601(long)`**
Mengonversi stempel waktu milidetik epoch menjadi stempel waktu. ISO8601
**`util.time.epochMilliSecondsToFormatted(long, String)`**
Mengonversi stempel waktu milidetik epoch, diteruskan selama, ke stempel waktu yang diformat sesuai dengan format yang disediakan di UTC.
**`util.time.epochMilliSecondsToFormatted(long, String, String)`**
Mengonversi stempel waktu milidetik epoch, diteruskan sebagai panjang, ke stempel waktu yang diformat sesuai dengan format yang disediakan di zona waktu yang disediakan.
# Pembantu DynamoDB di util.dynamodb
`util.dynamodb`berisi metode pembantu yang memudahkan untuk menulis dan membaca data ke Amazon DynamoDB, seperti pemetaan dan pemformatan tipe otomatis.
## ToDynamoDB
### Daftar utilitas ToDynamoDB
**`util.dynamodb.toDynamoDB(Object)`**
Alat konversi objek umum untuk DynamoDB yang mengubah objek masukan ke representasi DynamoDB yang sesuai. Ini berpendirian tentang bagaimana itu mewakili beberapa jenis: misalnya, itu akan menggunakan daftar (“L”) daripada set (“SS”, “NS”, “BS”). Ini mengembalikan sebuah objek yang menggambarkan nilai atribut DynamoDB.
**Contoh string**
```
Input: util.dynamodb.toDynamoDB("foo")
Output: { "S" : "foo" }
```
**Contoh angka**
```
Input: util.dynamodb.toDynamoDB(12345)
Output: { "N" : 12345 }
```
**Contoh Boolean**
```
Input: util.dynamodb.toDynamoDB(true)
Output: { "BOOL" : true }
```
**Daftar contoh**
```
Input: util.dynamodb.toDynamoDB([ "foo", 123, { "bar" : "baz" } ])
Output: {
"L" : [
{ "S" : "foo" },
{ "N" : 123 },
{
"M" : {
"bar" : { "S" : "baz" }
}
}
]
}
```
**Contoh peta**
```
Input: util.dynamodb.toDynamoDB({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] })
Output: {
"M" : {
"foo" : { "S" : "bar" },
"baz" : { "N" : 1234 },
"beep" : {
"L" : [
{ "S" : "boop" }
]
}
}
}
```
## ToString utilitas
### Daftar utilitas ToString
**`util.dynamodb.toString(String)`**
Mengkonversi string input ke format string DynamoDB. Ini mengembalikan sebuah objek yang menggambarkan nilai atribut DynamoDB.
```
Input: util.dynamodb.toString("foo")
Output: { "S" : "foo" }
```
**`util.dynamodb.toStringSet(List)`**
Mengkonversi daftar dengan Strings ke format set string DynamoDB. Ini mengembalikan sebuah objek yang menggambarkan nilai atribut DynamoDB.
```
Input: util.dynamodb.toStringSet([ "foo", "bar", "baz" ])
Output: { "SS" : [ "foo", "bar", "baz" ] }
```
## utilitas Tonumber
### Daftar utilitas Tonumber
**`util.dynamodb.toNumber(Number)`**
Mengkonversi angka ke format nomor DynamoDB. Ini mengembalikan sebuah objek yang menggambarkan nilai atribut DynamoDB.
```
Input: util.dynamodb.toNumber(12345)
Output: { "N" : 12345 }
```
**`util.dynamodb.toNumberSet(List)`**
Mengkonversi daftar angka ke format set nomor DynamoDB. Ini mengembalikan sebuah objek yang menggambarkan nilai atribut DynamoDB.
```
Input: util.dynamodb.toNumberSet([ 1, 23, 4.56 ])
Output: { "NS" : [ 1, 23, 4.56 ] }
```
## Kegunaan toBinary
### Daftar utilitas toBinary
**`util.dynamodb.toBinary(String)`**
Mengkonversi data biner dikodekan sebagai string base64 ke format biner DynamoDB. Ini mengembalikan sebuah objek yang menggambarkan nilai atribut DynamoDB.
```
Input: util.dynamodb.toBinary("foo")
Output: { "B" : "foo" }
```
**`util.dynamodb.toBinarySet(List)`**
Mengkonversi daftar data biner yang dikodekan sebagai string base64 ke format set biner DynamoDB. Ini mengembalikan sebuah objek yang menggambarkan nilai atribut DynamoDB.
```
Input: util.dynamodb.toBinarySet([ "foo", "bar", "baz" ])
Output: { "BS" : [ "foo", "bar", "baz" ] }
```
## utilitas ToBoolean
### Daftar utilitas ToBoolean
**`util.dynamodb.toBoolean(Boolean)`**
Mengkonversi Boolean ke format DynamoDB Boolean yang sesuai. Ini mengembalikan sebuah objek yang menggambarkan nilai atribut DynamoDB.
```
Input: util.dynamodb.toBoolean(true)
Output: { "BOOL" : true }
```
## utilitas ToNull
### Daftar utilitas ToNull
**`util.dynamodb.toNull()`**
Mengembalikan null dalam format DynamoDB null. Ini mengembalikan sebuah objek yang menggambarkan nilai atribut DynamoDB.
```
Input: util.dynamodb.toNull()
Output: { "NULL" : null }
```
## utilitas ToList
### Daftar utilitas ToList
**`util.dynamodb.toList(List)`**
Mengkonversi daftar objek ke format daftar DynamoDB. Setiap item dalam daftar juga dikonversi ke format DynamoDB yang sesuai. Ini berpendapat tentang bagaimana itu mewakili beberapa objek bersarang: misalnya, itu akan menggunakan daftar (“L”) daripada set (“SS”, “NS”, “BS”). Ini mengembalikan sebuah objek yang menggambarkan nilai atribut DynamoDB.
```
Input: util.dynamodb.toList([ "foo", 123, { "bar" : "baz" } ])
Output: {
"L" : [
{ "S" : "foo" },
{ "N" : 123 },
{
"M" : {
"bar" : { "S" : "baz" }
}
}
]
}
```
## TomAp utilitas
### Daftar utilitas TomAP
**`util.dynamodb.toMap(Map)`**
Mengkonversi peta ke format peta DynamoDB. Setiap nilai dalam peta juga dikonversi ke format DynamoDB yang sesuai. Ini berpendapat tentang bagaimana itu mewakili beberapa objek bersarang: misalnya, itu akan menggunakan daftar (“L”) daripada set (“SS”, “NS”, “BS”). Ini mengembalikan sebuah objek yang menggambarkan nilai atribut DynamoDB.
```
Input: util.dynamodb.toMap({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] })
Output: {
"M" : {
"foo" : { "S" : "bar" },
"baz" : { "N" : 1234 },
"beep" : {
"L" : [
{ "S" : "boop" }
]
}
}
}
```
**`util.dynamodb.toMapValues(Map)`**
Membuat salinan peta di mana setiap nilai telah dikonversi ke format DynamoDB yang sesuai. Ini berpendapat tentang bagaimana itu mewakili beberapa objek bersarang: misalnya, itu akan menggunakan daftar (“L”) daripada set (“SS”, “NS”, “BS”).
```
Input: util.dynamodb.toMapValues({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] })
Output: {
"foo" : { "S" : "bar" },
"baz" : { "N" : 1234 },
"beep" : {
"L" : [
{ "S" : "boop" }
]
}
}
```
Ini sedikit berbeda `util.dynamodb.toMap(Map)` karena hanya mengembalikan isi dari nilai atribut DynamoDB, tetapi tidak seluruh nilai atribut itu sendiri. Misalnya, pernyataan berikut persis sama:
```
util.dynamodb.toMapValues(