本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
# 建立基本查詢 (JavaScript)
GraphQL 解析程式將類型結構描述中的欄位連接到資料來源。解析程式是滿足請求的機制。
Resolvers in AWS AppSync 使用 JavaScript 將 GraphQL 表達式轉換為資料來源可以使用的格式。或者，映射範本可以用 [Apache Velocity 範本語言 (VTL)](https://velocity.apache.org/engine/2.0/vtl-reference.html) 撰寫，將 GraphQL 表達式轉換為資料來源可以使用的格式。
本節說明如何使用 JavaScript 設定解析程式。[Resolver 教學課程 (JavaScript)](https://docs.aws.amazon.com/appsync/latest/devguide/tutorials-js.html) 區段提供如何使用 JavaScript 實作解析程式的深入教學課程。[Resolver 參考 (JavaScript)](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html) 區段提供可搭配 JavaScript 解析程式使用的公用程式操作說明。
我們建議您先遵循本指南，再嘗試使用上述任何教學課程。
在本節中，我們將逐步解說如何建立和設定查詢和變動的解析程式。
**注意**
本指南假設您已建立結構描述，並且至少有一個查詢或變動。如果您要尋找訂閱 （即時資料），請參閱[本指南](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-real-time-data.html)。
在本節中，我們將提供一些設定解析程式的一般步驟，以及使用下列結構描述的範例：
```
// schema.graphql file
input CreatePostInput {
title: String
date: AWSDateTime
}
type Post {
id: ID!
title: String
date: AWSDateTime
}
type Mutation {
createPost(input: CreatePostInput!): Post
}
type Query {
getPost: [Post]
}
```
## 建立基本查詢解析程式
本節將說明如何建立基本查詢解析程式。
------
#### [ Console ]
1. 登入 AWS 管理主控台 並開啟 [AppSync 主控台](https://console.aws.amazon.com/appsync/)。
1. 在 **APIs儀表板**中，選擇您的 GraphQL API。
1. 在**側邊欄中**，選擇**結構描述**。
1. 輸入結構描述和資料來源的詳細資訊。如需詳細資訊，請參閱[設計您的結構描述](https://docs.aws.amazon.com/appsync/latest/devguide/designing-your-schema.html)和[連接資料來源](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html)一節。
1. 在**結構描述**編輯器旁邊，有一個稱為**解析程式**的視窗。此方塊包含**結構描述**視窗中定義的類型和欄位清單。您可以將解析程式連接至欄位。您很可能將解析程式連接到您的欄位操作。在本節中，我們將介紹簡單的查詢組態。在**查詢**類型下，選擇查詢欄位旁的**連接**。
1. 在**連接解析程式**頁面的**解析程式類型**下，您可以選擇管道或單位解析程式。如需這些類型的詳細資訊，請參閱[解析程式](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-components.html)。本指南將使用 `pipeline resolvers`。
**提示**
建立管道解析程式時，您的資料來源會連接到管道函數 (s)。函數會在您建立管道解析程式本身後建立，因此此頁面中沒有設定它的選項。如果您使用的是單位解析程式，則資料來源會直接繫結至解析程式，因此您會在此頁面上設定。
針對**解析程式執行時間**，選擇`APPSYNC_JS`啟用 JavaScript 執行時間。
1. 您可以為此 API 啟用[快取](https://docs.aws.amazon.com/appsync/latest/devguide/enabling-caching.html)。我們建議您立即關閉此功能。選擇**建立**。
1. 在**編輯解析程式**頁面上，有一個稱為**解析程式程式碼**的程式碼編輯器，可讓您實作解析程式處理常式和回應的邏輯 （步驟前後）。如需詳細資訊，請參閱 [JavaScript 解析程式概觀](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html)。
**注意**
在我們的範例中，我們只會將請求保留空白，並將回應設定為從[內容](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html)傳回最後一個資料來源結果：
```
import {util} from '@aws-appsync/utils';
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
```
在本節下方，有一個名為 **Functions 的**資料表。函數可讓您實作可在多個解析程式間重複使用的程式碼。您可以視需要將原始程式碼儲存為新增至解析程式的函數，而不是持續重寫或複製程式碼。
函數構成管道操作清單的大量內容。在解析程式中使用多個函數時，您可以設定函數的順序，它們將按該順序執行。它們會在請求函數執行後和回應函數開始之前執行。
若要新增函數，請在**函數**下選擇**新增函數**，然後選擇**建立新函數**。或者，您可能會看到**建立函數**按鈕來選擇。
1. 選擇資料來源。這將是解析程式對其執行動作的資料來源。
**注意**
在我們的範例中，我們正在連接 的解析程式`getPost`，它會透過 擷取`Post`物件`id`。假設我們已為此結構描述設定 DynamoDB 資料表。其分割區索引鍵設定為 `id`，且為空白。
1. 輸入 `Function name`。
1. 在**函數程式碼**下，您需要實作函數的行為。這可能令人困惑，但每個函數都有自己的本機請求和回應處理常式。請求會執行，然後進行資料來源調用來處理請求，然後由回應處理常式處理資料來源回應。結果會存放在[內容](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html)物件中。之後，清單中的下一個函數會執行，如果是最後一個函數，則會傳遞至步驟後回應處理常式。
**注意**
在我們的範例中，我們會將解析程式連接至 `getPost`，從資料來源取得`Post`物件清單。我們的請求函數會從我們的資料表請求資料，資料表會將其回應傳遞至內容 (ctx)，然後回應會在內容中傳回結果。 AWS AppSync的強度在於其與其他 AWS 服務的互連性。由於我們使用 DynamoDB，因此我們有[一套操作](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html)來簡化這類操作。我們也有一些其他資料來源類型的樣板範例。
我們的程式碼如下所示：
```
import { util } from '@aws-appsync/utils';
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
return { operation: 'Scan' };
}
/**
* return a list of scanned post items
*/
export function response(ctx) {
return ctx.result.items;
}
```
在此步驟中，我們新增了兩個函數：
`request`：請求處理常式會對資料來源執行擷取操作。引數包含內容物件 (`ctx`) 或一些資料，可供執行特定操作的所有解析程式使用。例如，它可能包含授權資料、要解析的欄位名稱等。傳回陳述式會執行 [https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan](https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan)操作 （如需範例，請參閱[此處](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html))。由於我們使用 DynamoDB，因此我們可以使用該服務的一些操作。掃描會執行資料表中所有項目的基本擷取。此操作的結果會存放在內容物件中做為`result`容器，再傳遞給回應處理常式。在管道中的回應之前`request`執行 。
`response`：傳回 輸出的回應處理常式`request`。引數是更新的內容物件，而傳回陳述式是 `ctx.prev.result`。在本指南的這個階段，您可能不熟悉此值。 `ctx`是指內容物件。 `prev`是指管道中先前的操作，也就是我們的 `request`。`result` 包含解析程式在管道中移動時的結果 (s)。如果您將所有操作放在一起， `ctx.prev.result` 會傳回上次執行的操作結果，也就是請求處理常式。
1. 完成後，請選擇**建立**。
1. 返回解析程式畫面的**函數**下，選擇**新增函數**下拉式清單，並將函數新增至函數清單。
1. 選擇**儲存**以更新解析程式。
------
#### [ CLI ]
**新增您的 函數**
+ 使用 `[create-function](https://docs.aws.amazon.com/cli/latest/reference/appsync/create-function.html)`命令為您的管道解析程式建立 函數。
您需要為此特定命令輸入幾個參數：
1. 您 API `api-id`的 。
1. AWS AppSync 主控台中`name`函數的 。
1. 函數將使用的資料來源名稱 `data-source-name`或 。它必須已在 AWS AppSync 服務中建立並連結至您的 GraphQL API。
1. 函數的 `runtime`、 或 環境和語言。對於 JavaScript，名稱必須為 `APPSYNC_JS`，執行期為 `1.0.0`。
1. 函數的 `code`、 或 請求和回應處理常式。雖然您可以手動輸入，但將其新增至 .txt 檔案 （或類似格式），然後將其做為引數傳入會更為容易。
**注意**
我們的查詢程式碼將位於傳入為引數的檔案中：
```
import { util } from '@aws-appsync/utils';
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
return { operation: 'Scan' };
}
/**
* return a list of scanned post items
*/
export function response(ctx) {
return ctx.result.items;
}
```
範例命令可能如下所示：
```
aws appsync create-function \
--api-id abcdefghijklmnopqrstuvwxyz \
--name get_posts_func_1 \
--data-source-name table-for-posts \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file://~/path/to/file/{filename}.{fileType}
```
輸出會在 CLI 中傳回。範例如下：
```
{
"functionConfiguration": {
"functionId": "ejglgvmcabdn7lx75ref4qeig4",
"functionArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/functions/ejglgvmcabdn7lx75ref4qeig4",
"name": "get_posts_func_1",
"dataSourceName": "table-for-posts",
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
**注意**
請務必在`functionId`某處記錄 ，因為這將用於將函數連接至解析程式。
**建立您的解析程式**
+ 執行 `[create-resolver](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)`命令`Query`，為 建立管道函數。
您需要為此特定命令輸入幾個參數：
1. 您 API `api-id`的 。
1. `type-name`結構描述中的 或特殊物件類型 （查詢、變動、訂閱）。
1. 在您欲連接解析程式之特殊物件類型內的 `field-name`或 欄位操作。
1. `kind`，指定單位或管道解析程式。將此設為 `PIPELINE`以啟用管道函數。
1. 要連接到解析程式的 (`pipeline-config`或） 函數。請確定您知道函數`functionId`的值。列出順序很重要。
1. `runtime`，也就是 `APPSYNC_JS`(JavaScript)。`runtimeVersion` 目前為 `1.0.0`。
1. `code`，其中包含步驟處理常式前後的 。
**注意**
我們的查詢程式碼將位於傳入為引數的檔案中：
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
const { id, ...values } = ctx.args;
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id }),
attributeValues: util.dynamodb.toMapValues(values),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
範例命令可能如下所示：
```
aws appsync create-resolver \
--api-id abcdefghijklmnopqrstuvwxyz \
--type-name Query \
--field-name getPost \
--kind PIPELINE \
--pipeline-config functions=ejglgvmcabdn7lx75ref4qeig4 \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
輸出會在 CLI 中傳回。範例如下：
```
{
"resolver": {
"typeName": "Mutation",
"fieldName": "getPost",
"resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Mutation/resolvers/getPost",
"kind": "PIPELINE",
"pipelineConfig": {
"functions": [
"ejglgvmcabdn7lx75ref4qeig4"
]
},
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
------
#### [ CDK ]
**提示**
在使用 CDK 之前，我們建議您檢閱 CDK 的[官方文件](https://docs.aws.amazon.com/cdk/v2/guide/home.html)以及 CDK AWS AppSync參考。 [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html)
下列步驟只會顯示用來新增特定資源之程式碼片段的一般範例。這**並非**您生產程式碼中的工作解決方案。我們也假設您已經有運作中的應用程式。
基本應用程式將需要下列項目：
1. 服務匯入指令
1. 結構描述程式碼
1. 資料來源產生器
1. 函數程式碼
1. 解析程式程式碼
從[設計您的結構描述](https://docs.aws.amazon.com/appsync/latest/devguide/designing-your-schema.html)和[連接資料來源](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html)區段中，我們知道堆疊檔案將包含格式的匯入指令：
```
import * as x from 'x'; # import wildcard as the 'x' keyword from 'x-service'
import {a, b, ...} from 'c'; # import {specific constructs} from 'c-service'
```
**注意**
在先前的章節中，我們只說明了如何匯入 AWS AppSync 建構。在真實程式碼中，您必須匯入更多服務，才能執行應用程式。在我們的範例中，如果我們要建立非常簡單的 CDK 應用程式，我們至少會匯入 AWS AppSync 服務與資料來源，也就是 DynamoDB 資料表。我們還需要匯入一些額外的建構，才能部署應用程式：
```
import * as cdk from 'aws-cdk-lib';
import * as appsync from 'aws-cdk-lib/aws-appsync';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
import { Construct } from 'constructs';
```
若要摘要下列各項：
`import * as cdk from 'aws-cdk-lib';`：這可讓您定義 CDK 應用程式和建構，例如堆疊。它還包含一些實用的公用程式函數，適用於我們的應用程式，例如操作中繼資料。如果您熟悉此匯入指令，但想知道為何此處未使用 cdk 核心程式庫，請參閱[遷移](https://docs.aws.amazon.com/cdk/v2/guide/migrating-v2.html)頁面。
`import * as appsync from 'aws-cdk-lib/aws-appsync';`：這會匯入[AWS AppSync 服務](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html)。
`import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';`：這會匯入 [DynamoDB 服務](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb-readme.html)。
`import { Construct } from 'constructs';`：我們需要此項目來定義根[建構](https://docs.aws.amazon.com/cdk/v2/guide/constructs.html)。
匯入的類型取決於您呼叫的服務。我們建議您查看 CDK 文件以取得範例。頁面頂端的結構描述將是 CDK 應用程式中的個別檔案，做為 `.graphql` 檔案。在堆疊檔案中，我們可以使用下列格式將其與新的 GraphQL 建立關聯：
```
const add_api = new appsync.GraphqlApi(this, 'graphQL-example', {
name: 'my-first-api',
schema: appsync.SchemaFile.fromAsset(path.join(__dirname, 'schema.graphql')),
});
```
**注意**
在範圍 中`add_api`，我們使用`new`關鍵字後面接著 來新增 GraphQL API`appsync.GraphqlApi(scope: Construct, id: string , props: GraphqlApiProps)`。我們的範圍是 `this`，CFN id 是 `graphQL-example`，而我們的道具是 `my-first-api`（主控台中 API 的名稱） 和 `schema.graphql`（結構描述檔案的絕對路徑）。
若要新增資料來源，您必須先將資料來源新增至堆疊。然後，您需要使用來源特定方法將其與 GraphQL API 建立關聯。當您建立解析程式函數時，就會發生關聯。同時，讓我們使用 建立 DynamoDB 資料表的範例`dynamodb.Table`：
```
const add_ddb_table = new dynamodb.Table(this, 'posts-table', {
partitionKey: {
name: 'id',
type: dynamodb.AttributeType.STRING,
},
});
```
**注意**
如果我們在範例中使用此值，則會新增 CFN ID 為 `posts-table`且分割區索引鍵為 的新 DynamoDB 資料表`id (S)`。
接下來，我們需要在堆疊檔案中實作解析程式。以下是掃描 DynamoDB 資料表中所有項目的簡單查詢範例：
```
const add_func = new appsync.AppsyncFunction(this, 'func-get-posts', {
name: 'get_posts_func_1',
add_api,
dataSource: add_api.addDynamoDbDataSource('table-for-posts', add_ddb_table),
code: appsync.Code.fromInline(`
export function request(ctx) {
return { operation: 'Scan' };
}
export function response(ctx) {
return ctx.result.items;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
});
new appsync.Resolver(this, 'pipeline-resolver-get-posts', {
add_api,
typeName: 'Query',
fieldName: 'getPost',
code: appsync.Code.fromInline(`
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
pipelineConfig: [add_func],
});
```
**注意**
首先，我們建立了名為 的函數`add_func`。此建立順序可能看起來有點反直覺，但您必須在管道解析程式中建立函數，才能建立解析程式本身。函數的形式如下：
```
AppsyncFunction(scope: Construct, id: string, props: AppsyncFunctionProps)
```
我們的範圍是 `this`，我們的 CFN ID 是 `func-get-posts`，而我們的道具包含實際的函數詳細資訊。在道具內，我們包括：
將出現在 AWS AppSync 主控台的 `name` 函數的 (`get_posts_func_1`)。
我們先前建立的 GraphQL API (`add_api`)。
資料來源；這是我們將資料來源連結至 GraphQL API 值，然後將其連接至函數的點。我們採用我們建立的資料表 (`add_ddb_table`)，並使用其中一種`GraphqlApi`方法 (`add_api`) 將其連接到 GraphQL API ()[https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.GraphqlApi.html#addwbrdynamowbrdbwbrdatawbrsourceid-table-options](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.GraphqlApi.html#addwbrdynamowbrdbwbrdatawbrsourceid-table-options)。ID 值 (`table-for-posts`) 是主控台中 AWS AppSync 資料來源的名稱。如需來源特定方法的清單，請參閱下列頁面：
[ DynamoDbDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.DynamoDbDataSource.html)
[ EventBridgeDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.EventBridgeDataSource.html)
[ HttpDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.HttpDataSource.html)
[ LambdaDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.LambdaDataSource.html)
[ NoneDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.NoneDataSource.html)
[ OpenSearchDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.OpenSearchDataSource.html)
[ RdsDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.RdsDataSource.html)
程式碼包含函數的請求和回應處理常式，這是簡單的掃描和傳回。
執行時間指定要使用 APPSYNC\$1JS 執行時間 1.0.0 版。請注意，目前這是 APPSYNC\$1JS 唯一可用的版本。
接下來，我們需要將 函數連接至管道解析程式。我們建立解析程式的方式如下：
```
Resolver(scope: Construct, id: string, props: ResolverProps)
```
我們的範圍是 `this`，我們的 CFN ID 是 `pipeline-resolver-get-posts`，而我們的道具包含實際的函數詳細資訊。在道具中，我們包括：
我們先前建立的 GraphQL API (`add_api`)。
特殊物件類型名稱；這是查詢操作，因此我們只會新增值 `Query`。
欄位名稱 (`getPost`) 是 `Query`類型下結構描述中的欄位名稱。
此程式碼包含處理常式前後的 。我們的範例只會傳回函數執行其操作後，內容中的任何結果。
執行時間指定要使用 APPSYNC\$1JS 執行時間 1.0.0 版。請注意，目前這是 APPSYNC\$1JS 唯一可用的版本。
管道組態包含我們所建立函數的參考 (`add_func`)。
------
為了摘要此範例中發生的情況，您看到了實作請求和回應處理常式的 AWS AppSync 函數。函數負責與您的資料來源互動。請求處理常式將 `Scan` 操作傳送到 AWS AppSync，指示它針對 DynamoDB 資料來源執行的操作。回應處理常式傳回項目清單 (`ctx.result.items`)。然後，項目清單會自動映射至 `Post` GraphQL 類型。
## 建立基本變動解析程式
本節將說明如何建立基本的變動解析程式。
------
#### [ Console ]
1. 登入 AWS 管理主控台 並開啟 [AppSync 主控台](https://console.aws.amazon.com/appsync/)。
1. 在 **APIs儀表板**中，選擇您的 GraphQL API。
1. 在**側邊欄中**，選擇**結構描述**。
1. 在**解析程式**區段和**變動**類型下，選擇欄位旁的**連接**。
**注意**
在我們的範例中，我們正在連接 的解析程式`createPost`，這會將`Post`物件新增至我們的資料表。假設我們使用上一節的相同 DynamoDB 資料表。其分割區索引鍵設定為 `id`，且為空白。
1. 在**連接解析程式**頁面的**解析程式類型**下，選擇 `pipeline resolvers`。提醒您，您可以[在這裡](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-components.html)找到有關解析程式的詳細資訊。針對**解析程式執行時間**，選擇 `APPSYNC_JS`以啟用 JavaScript 執行時間。
1. 您可以為此 API 啟用[快取](https://docs.aws.amazon.com/appsync/latest/devguide/enabling-caching.html)。我們建議您立即關閉此功能。選擇**建立**。
1. 選擇**新增函數**，然後選擇**建立新函數**。或者，您可能會看到**建立函數**按鈕來選擇。
1. 選擇您的資料來源。這應該是您要使用變動操作資料的來源。
1. 輸入 `Function name`。
1. 在**函數程式碼**下，您需要實作函數的行為。這是一個變動，因此請求最好會對調用的資料來源執行一些狀態變更操作。結果將由回應函數處理。
**注意**
`createPost` 正在新增或 "putting" 資料表`Post`中的新 ，並將我們的參數做為資料。我們可以新增如下內容：
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
在此步驟中，我們也新增了 `request`和 `response`函數：
`request`：請求處理常式接受內容做為引數。請求處理常式傳回陳述式會執行 [https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem](https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem)命令，這是內建的 DynamoDB 操作 （如需範例，請參閱[此處](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-2.html)或[此處](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData))。`PutItem` 命令會採用分割區`key`值 （由 自動產生`util.autoid()`) 並從內容引數輸入 `attributes` （這些是我們將在請求中傳遞的值），將`Post`物件新增至 DynamoDB 資料表。`key` 是 `id`，而 `attributes`是 `date`和 `title` 欄位引數。它們都是透過[https://docs.aws.amazon.com//appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html#utility-helpers-in-toMap-js](https://docs.aws.amazon.com//appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html#utility-helpers-in-toMap-js)協助程式預先格式化，以使用 DynamoDB 資料表。
`response`：回應接受更新的內容，並傳回請求處理常式的結果。
1. 完成後選擇**建立**。
1. 返回解析程式畫面的**函數**下，選擇**新增函數**下拉式清單，並將函數新增至函數清單。
1. 選擇**儲存**以更新解析程式。
------
#### [ CLI ]
**新增您的 函數**
+ 使用 `[create-function](https://docs.aws.amazon.com/cli/latest/reference/appsync/create-function.html)`命令為您的管道解析程式建立 函數。
您需要為此特定命令輸入幾個參數：
1. 您 API `api-id`的 。
1. AWS AppSync 主控台中`name`函數的 。
1. `data-source-name`或 函數將使用的資料來源名稱。它必須已在 AWS AppSync 服務中建立並連結至您的 GraphQL API。
1. 函數的 `runtime`、 或 環境和語言。對於 JavaScript，名稱必須為 `APPSYNC_JS`，執行期為 `1.0.0`。
1. 函數的 `code`、 或 請求和回應處理常式。雖然您可以手動輸入，但將其新增至 .txt 檔案 （或類似格式），然後將其做為引數傳入會更為容易。
**注意**
我們的查詢程式碼將位於傳入為引數的檔案中：
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
範例命令可能如下所示：
```
aws appsync create-function \
--api-id abcdefghijklmnopqrstuvwxyz \
--name add_posts_func_1 \
--data-source-name table-for-posts \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
輸出會在 CLI 中傳回。範例如下：
```
{
"functionConfiguration": {
"functionId": "vulcmbfcxffiram63psb4dduoa",
"functionArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/functions/vulcmbfcxffiram63psb4dduoa",
"name": "add_posts_func_1",
"dataSourceName": "table-for-posts",
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output foes here"
}
}
```
**注意**
請務必在`functionId`某處記錄 ，因為這將用於將函數連接至解析程式。
**建立您的解析程式**
+ `Mutation` 執行 `[create-resolver](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)`命令來建立 的管道函數。
您需要為此特定命令輸入幾個參數：
1. 您 API `api-id`的 。
1. 結構描述中的 `type-name`或特殊物件類型 （查詢、變動、訂閱）。
1. 在您欲連接解析程式之特殊物件類型內的 `field-name`或 欄位操作。
1. `kind`，指定單位或管道解析程式。將此設為 `PIPELINE`以啟用管道函數。
1. 要連接到解析程式的 `pipeline-config`（或） 函數。請確定您知道函數`functionId`的值。列出 的順序很重要。
1. `runtime`，也就是 `APPSYNC_JS`(JavaScript)。`runtimeVersion` 目前為 `1.0.0`。
1. `code`，其中包含步驟前後的 。
**注意**
我們的查詢程式碼將位於傳入為引數的檔案中：
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
const { id, ...values } = ctx.args;
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id }),
attributeValues: util.dynamodb.toMapValues(values),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
範例命令可能如下所示：
```
aws appsync create-resolver \
--api-id abcdefghijklmnopqrstuvwxyz \
--type-name Mutation \
--field-name createPost \
--kind PIPELINE \
--pipeline-config functions=vulcmbfcxffiram63psb4dduoa \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
輸出會在 CLI 中傳回。範例如下：
```
{
"resolver": {
"typeName": "Mutation",
"fieldName": "createPost",
"resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Mutation/resolvers/createPost",
"kind": "PIPELINE",
"pipelineConfig": {
"functions": [
"vulcmbfcxffiram63psb4dduoa"
]
},
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
------
#### [ CDK ]
**提示**
在使用 CDK 之前，我們建議您檢閱 CDK 的[官方文件](https://docs.aws.amazon.com/cdk/v2/guide/home.html)以及 CDK AWS AppSync參考。 [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html)
下列步驟只會顯示用來新增特定資源之程式碼片段的一般範例。這**並非**您生產程式碼中的工作解決方案。我們也假設您已經有運作中的應用程式。
+ 若要進行變動，假設您在同一個專案中，您可以將它新增至堆疊檔案，例如查詢。以下是變動的修改函數和解析程式，會將新的 新增至`Post`資料表：
```
const add_func_2 = new appsync.AppsyncFunction(this, 'func-add-post', {
name: 'add_posts_func_1',
add_api,
dataSource: add_api.addDynamoDbDataSource('table-for-posts-2', add_ddb_table),
code: appsync.Code.fromInline(`
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
export function response(ctx) {
return ctx.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
});
new appsync.Resolver(this, 'pipeline-resolver-create-posts', {
add_api,
typeName: 'Mutation',
fieldName: 'createPost',
code: appsync.Code.fromInline(`
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
pipelineConfig: [add_func_2],
});
```
**注意**
由於此變動和查詢結構類似，我們只會說明我們為了進行變動所做的變更。
在 函數中，我們將 CFN ID 變更為 `func-add-post`，並將名稱變更為 `add_posts_func_1` ，以反映我們將`Posts`新增至資料表的事實。在資料來源中，我們在 AWS AppSync 主控台中與資料表 (`add_ddb_table`) 建立新的關聯，`table-for-posts-2`因為 `addDynamoDbDataSource`方法需要它。請記住，這個新的關聯仍在使用先前建立的相同資料表，但我們現在在 AWS AppSync 主控台中有兩個與其連線：一個用於查詢 ，`table-for-posts`另一個用於變動 `table-for-posts-2`。程式碼已變更為新增 ，`Post`方法是自動產生其`id`值，並接受用戶端對其餘欄位的輸入。
在解析程式中，我們將 ID 值變更為 `pipeline-resolver-create-posts`，以反映我們將`Posts`新增至資料表的事實。為了反映結構描述中的變動，類型名稱已變更為 `Mutation`，而名稱為 `createPost`。管道組態已設定為我們的新變動函數 `add_func_2`。
------
為了摘要此範例中發生的情況， AWS AppSync 會自動將 欄位中定義的引數`createPost`從 GraphQL 結構描述轉換為 DynamoDB 操作。此範例使用 金鑰在 DynamoDB 中存放記錄`id`，該金鑰是使用我們的 `util.autoId()` 協助程式自動建立的。您從 AWS AppSync 主控台提出的請求或其他方式傳遞到內容引數 (`ctx.args.input`) 的所有其他欄位都會儲存為資料表的屬性。金鑰和屬性都會使用 `util.dynamodb.toMapValues(values)` 協助程式自動映射至相容的 DynamoDB 格式。
AWS AppSync 也支援用於編輯解析程式的測試和偵錯工作流程。您可以使用模擬`context`物件來查看範本的轉換值，然後再叫用它。或者，您可以在執行查詢時以互動方式檢視對資料來源的完整請求。如需詳細資訊，請參閱[測試和偵錯解析程式 (JavaScript)](https://docs.aws.amazon.com/appsync/latest/devguide/test-debug-resolvers-js.html) 和[監控和記錄](https://docs.aws.amazon.com/appsync/latest/devguide/monitoring.html#aws-appsync-monitoring)。
## 進階解析程式
如果您遵循[設計結構描述](designing-your-schema.md#aws-appsync-designing-your-schema)中的選用分頁區段，您仍然需要將解析程式新增至您的請求，才能使用分頁。我們的範例使用稱為 的查詢分頁`getPosts`，一次只傳回請求的一部分物件。解析程式在該欄位上的程式碼可能如下所示：
```
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
const { limit = 20, nextToken } = ctx.args;
return { operation: 'Scan', limit, nextToken };
}
/**
* @returns the result of the `put` operation
*/
export function response(ctx) {
const { items: posts = [], nextToken } = ctx.result;
return { posts, nextToken };
}
```
在請求中，我們會傳入請求的內容。我們的 `limit`是 *20*，這表示我們在第一個查詢`Posts`中傳回最多 20 個。我們的`nextToken`游標會固定為資料來源中的第一個`Post`項目。這些會傳遞給 args。然後，請求會執行從第一個`Post`到掃描限制數量的掃描。資料來源會將結果存放在內容中，該內容會傳遞給回應。回應會傳回`Posts`其擷取的 ，然後將 `nextToken` 設定為限制之後`Post`的項目。下一個請求會傳送到 以執行完全相同的物件，但在第一個查詢後立即從位移開始。請記住，這些類型的請求是依序完成的，而不是平行的。