本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。 # 的 VTL 解析程式教學課程 AWS AppSync **注意** 我們現在主要支援 APPSYNC\$1JS 執行期及其文件。請考慮[在此處](https://docs.aws.amazon.com/appsync/latest/devguide/tutorials-js.html)使用 APPSYNC\$1JS 執行期及其指南。 AWS AppSync 會使用資料來源和解析程式來翻譯 GraphQL 請求，並從 AWS 資源擷取資訊。 AWS AppSync 支援使用特定資料來源類型的自動佈建和連線。 AWS AppSync 也支援 Amazon DynamoDB AWS Lambda、關聯式資料庫 (Amazon Aurora Serverless)、Amazon OpenSearch Service 和 HTTP 端點做為資料來源。您可以將 GraphQL API 與現有的 AWS 資源搭配使用，或從頭建置資料來源和解析程式。以下章節旨在以教學的形式闡明一些較常見的 GraphQL 使用案例。 AWS AppSync 使用解析程式以 Apache Velocity 範本語言 (VTL) 編寫的*映射*範本。如需使用映射範本的詳細資訊，請參閱[解析程式映射範本參考](resolver-mapping-template-reference.md#aws-appsync-resolver-mapping-template-reference)。如需使用 VTL 的詳細資訊，請參閱[解析程式映射範本程式設計指南](resolver-mapping-template-reference-programming-guide.md#aws-appsync-resolver-mapping-template-reference-programming-guide)。 AWS AppSync 支援從 GraphQL 結構描述自動佈建 DynamoDB 資料表，如從結構描述佈建 （選用） 和啟動範例結構描述中所述。您也可以從現有將建立結構描述和連接解析程式的 DynamoDB 資料表滙入。這在從 Amazon DynamoDB 匯入中概述 （選用）。 **Topics** + [使用 DynamoDB 解析程式建立簡單的貼文應用程式](tutorial-dynamodb-resolvers.md) + [使用 AWS Lambda 解析程式](tutorial-lambda-resolvers.md) + [使用 OpenSearch Service 解析程式](tutorial-elasticsearch-resolvers.md) + [使用本機解析程式](tutorial-local-resolvers.md) + [結合 GraphQL 解析程式](tutorial-combining-graphql-resolvers.md) + [使用 DynamoDB 批次操作](tutorial-dynamodb-batch.md) + [執行 DynamoDB 交易](tutorial-dynamodb-transact.md) + [使用 HTTP 解析程式](tutorial-http-resolvers.md) + [使用 Aurora Serverless v2 解析程式](tutorial-rds-resolvers.md) + [使用管道解析程式](tutorial-pipeline-resolvers.md) + [在版本控制的資料來源上使用 Delta Sync 操作](tutorial-delta-sync.md) # 使用 DynamoDB 解析程式建立簡單的貼文應用程式 **注意** 我們現在主要支援 APPSYNC\$1JS 執行期及其文件。請考慮[在此處](https://docs.aws.amazon.com/appsync/latest/devguide/tutorials-js.html)使用 APPSYNC\$1JS 執行期及其指南。 本教學課程說明如何將自己的 Amazon DynamoDB 資料表帶到 AWS AppSync，並將其連接到 GraphQL API。 您可以讓 AWS AppSync 代表您佈建 DynamoDB 資源。或者，如果您願意，您可以透過建立資料來源和解析程式來將現有的資料表連接到 GraphQL 結構描述。在這兩種情況下，您將能夠透過 GraphQL 陳述式讀取和寫入 DynamoDB 資料庫，以及訂閱即時資料。 有您必須完成的特定的組態步驟，才能讓 GraphQL 陳述式轉譯到 DynamoDB 操作，以及讓回應轉譯回 GraphQL。本教學課程概述透過幾個真實世界案例和資料存取模式的組態程序。 ## 設定 DynamoDB 資料表 若要開始本教學課程，您必須先遵循下列步驟來佈建 AWS 資源。 1. 在 CLI 中使用下列 AWS CloudFormation 範本佈建 AWS 資源： ``` aws cloudformation create-stack \ --stack-name AWSAppSyncTutorialForAmazonDynamoDB \ --template-url https://s3.us-west-2.amazonaws.com/awsappsync/resources/dynamodb/AmazonDynamoDBCFTemplate.yaml \ --capabilities CAPABILITY_NAMED_IAM ``` 或者，您可以在帳戶中 AWS 的美國西部 2 （奧勒岡） 區域啟動下列 CloudFormation 堆疊。 [https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/dynamodb/AmazonDynamoDBCFTemplate.yaml](https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/dynamodb/AmazonDynamoDBCFTemplate.yaml) 這將會建立下列項目： + 稱為 `AppSyncTutorial-Post`的 DynamoDB 資料表，可存放`Post`資料。 + IAM 角色和相關聯的 IAM 受管政策，以允許 AWS AppSync 與`Post`資料表互動。 1. 要查看有關堆疊和建立的資源的詳細資訊，請執行以下 CLI 命令： ``` aws cloudformation describe-stacks --stack-name AWSAppSyncTutorialForAmazonDynamoDB ``` 1. 之後若要刪除資源，您可以執行以下項目： ``` aws cloudformation delete-stack --stack-name AWSAppSyncTutorialForAmazonDynamoDB ``` ## 建立 GraphQL API 若要在 AWS AppSync 中建立 GraphQL API： 1. 登入 AWS 管理主控台 並開啟 [AppSync 主控台](https://console.aws.amazon.com/appsync/)。 1. 在 **APIs儀表板**中，選擇**建立 API**。 1. 在**自訂您的 API 或從 Amazon DynamoDB 匯入**視窗下，選擇**從頭建置**。 1. 選擇相同視窗右側的**開始**。 1. 在 **API 名稱**欄位中，將 API 的名稱設定為 `AWSAppSyncTutorial`。 1. 選擇**建立**。 AWS AppSync 主控台會使用 API 金鑰身分驗證模式為您建立新的 GraphQL API。您可以使用主控台來設定其他 GraphQL API 和對其執行查詢，以進行此教學的其他部分。 ## 定義基本文章 API 現在您已建立 an AWS AppSync GraphQL API，您可以設定基本結構描述，以允許基本建立、擷取和刪除文章資料。 1. 登入 AWS 管理主控台 並開啟 [AppSync 主控台](https://console.aws.amazon.com/appsync/)。 1. 在 **APIs儀表板**中，選擇您剛建立的 API。 1. 在**側邊欄中**，選擇**結構描述**。 1. 在**結構描述**窗格中，使用下列程式碼取代內容： ``` schema { query: Query mutation: Mutation } type Query { getPost(id: ID): Post } type Mutation { addPost( id: ID! author: String! title: String! content: String! url: String! ): Post! } type Post { id: ID! author: String title: String content: String url: String ups: Int! downs: Int! version: Int! } ``` 1. 選擇**儲存**。 這個結構描述會定義 `Post` 類型和操作以新增和取得 `Post` 物件。 ## 設定 DynamoDB 資料表的資料來源 接著，將結構描述中定義的查詢和變動連結至 `AppSyncTutorial-Post`DynamoDB 資料表。 首先， AWS AppSync 需要注意您的資料表。您可以在 AWS AppSync 中設定資料來源來執行此操作： 1. 登入 AWS 管理主控台 並開啟 [AppSync 主控台](https://console.aws.amazon.com/appsync/)。 1. 在 **APIs儀表板**中，選擇您的 GraphQL API。 1. 在**側邊欄中**，選擇**資料來源**。 1. 選擇 **Create data source (建立資料來源)**。 1. 對於**資料來源名稱**，在 中輸入 `PostDynamoDBTable`。 1. 針對**資料來源類型**，選擇 **Amazon DynamoDB 資料表**。 1. 針對**區域**，選擇 **US-WEST-2**。 1. 針對**資料表名稱**，選擇 **AppSyncTutorial-Post** DynamoDB 資料表。 1. 建立新的 IAM 角色 （建議） 或選擇具有 IAM `lambda:invokeFunction` 許可的現有角色。現有角色需要信任政策，如[連接資料來源](attaching-a-data-source.md)一節所述。 以下是 IAM 政策範例，其具有對資源執行操作所需的許可： ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "lambda:invokeFunction" ], "Resource": [ "arn:aws:lambda:us-east-1:111122223333:function:myFunction", "arn:aws:lambda:us-east-1:111122223333:function:myFunction:*" ] } ] } ``` ------ 1. 選擇**建立**。 ## 設定 addPost 解析程式 (DynamoDB PutItem) After AWS AppSync 知道 DynamoDB 資料表，您可以透過定義**解析程式**將其連結至個別查詢和變動。您建立的第一個解析程式是`addPost`解析程式，可讓您在 `AppSyncTutorial-Post` DynamoDB 資料表中建立文章。 解析程式具有下列元件： + 在 GraphQL 結構描述中要附加解析程式的位置。在這種情況下，您會對 `addPost` 類型上的 `Mutation` 欄位設定解析程式。發起人呼叫 `mutation { addPost(...){...} }` 時會叫用此解析程式。 + 用於此解析程式的資料來源。在這種情況下，您想要使用先前定義的 `PostDynamoDBTable` 資料來源，如此您可以將項目新增到 `AppSyncTutorial-Post` DynamoDB 資料表。 + 請求映射範本。請求映射範本的目的是從發起人取得傳入請求，並將其轉換為指示 for AWS AppSync 以對 DynamoDB 執行。 + 回應映射範本。回應映射範本的任務即是從 DynamoDB 取得回應，並將其轉譯為 GraphQL 期望的項目。如果 DynamoDB 中的資料形狀與 GraphQL 中的 `Post` 類型不同，此功能會很有用，但如果他們的形狀一樣，您只需傳遞資料。 設定解析程式： 1. 登入 AWS 管理主控台 並開啟 [AppSync 主控台](https://console.aws.amazon.com/appsync/)。 1. 在 **APIs儀表板**中，選擇您的 GraphQL API。 1. 在**側邊欄中**，選擇**資料來源**。 1. 選擇 **Create data source (建立資料來源)**。 1. 對於**資料來源名稱**，在 中輸入 `PostDynamoDBTable`。 1. 針對**資料來源類型**，選擇 **Amazon DynamoDB 資料表**。 1. 針對**區域**，選擇 **US-WEST-2**。 1. 針對**資料表名稱**，選擇 **AppSyncTutorial-Post** DynamoDB 資料表。 1. 建立新的 IAM 角色 （建議） 或選擇具有 IAM `lambda:invokeFunction` 許可的現有角色。現有角色需要信任政策，如[連接資料來源](attaching-a-data-source.md)一節所述。 以下是 IAM 政策範例，其具有對資源執行操作所需的許可： ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "lambda:invokeFunction" ], "Resource": [ "arn:aws:lambda:us-west-2:123456789012:function:myFunction", "arn:aws:lambda:us-west-2:123456789012:function:myFunction:*" ] } ] } ``` ------ 1. 選擇**建立**。 1. 選擇 **Schema (結構描述)** 標籤。 1. 在右側的**資料類型**窗格中，尋找**變動**類型的 **addPost** 欄位，然後選擇**連接**。 1. 在**動作功能表中**，選擇**更新執行時間**，然後選擇**單位解析程式 （僅限 VTL)**。 1. 在 **Data source name (資料來源名稱)** 中，選擇 **PostDynamoDBTable**。 1. 將以下內容貼到 **Configure the request mapping template (設定請求映射範本)** 區段： ``` { "version" : "2017-02-28", "operation" : "PutItem", "key" : { "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id) }, "attributeValues" : { "author" : $util.dynamodb.toDynamoDBJson($context.arguments.author), "title" : $util.dynamodb.toDynamoDBJson($context.arguments.title), "content" : $util.dynamodb.toDynamoDBJson($context.arguments.content), "url" : $util.dynamodb.toDynamoDBJson($context.arguments.url), "ups" : { "N" : 1 }, "downs" : { "N" : 0 }, "version" : { "N" : 1 } } } ``` **注意：**所有金鑰和屬性值皆有指定的*類型*。例如，您將 `author` 欄位設為 `{ "S" : "${context.arguments.author}" }`。`S` 部分指出 to AWS AppSync 和 DynamoDB 的值將是字串值。會將實際值填入 `author` 引數。同樣地，`version` 欄位是號碼欄位，因為它會將 `N` 用於類型。最後，您也可以初始化 `ups`、`downs` 和 `version` 欄位。 在本教學課程中，您已指定 GraphQL `ID!`類型，該類型會將插入 DynamoDB 的新項目編製索引，做為 client arguments. AWS AppSync comes 的一部分，其中包含名為 的自動 ID 產生公用程式`$utils.autoId()`，您也可以以 的形式使用`"id" : { "S" : "${$utils.autoId()}" }`。然後，您可以直接將 `id: ID!` 移出 `addPost()` 的結構描述定義，該 ID 便會自動插入。您不會在本教學課程中使用此技術，但您應該將其視為寫入 DynamoDB 資料表時的最佳實務。 如需映射範本的詳細資訊，請參閱[解析程式映射範本概觀](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview)參考文件。如需 GetItem 要求映射的詳細資訊，請參閱 [GetItem](aws-appsync-resolver-mapping-template-reference-dynamodb-getitem.md) 參考文件。如需有關類型的詳細資訊，請參閱[類型系統 (要求映射)](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) 參考文件。 1. 將以下內容貼到 **Configure the response mapping template (設定回應映射範本)** 區段： ``` $utils.toJson($context.result) ``` **注意：**由於 `AppSyncTutorial-Post` 資料表中的資料形狀正好與 GraphQL 中的 `Post` 類型形狀相符，回應映射範本只需直接傳遞結果。另請注意，此教學課程中的所有範例會使用相同的回應映射範本，因此您只需建立一個檔案。 1. 選擇**儲存**。 ### 呼叫 API 以新增文章 現在已設定解析程式， AWS AppSync 可以將傳入`addPost`的變動轉譯為 DynamoDB PutItem 操作。您現在可以執行變動以將項目放置到資料表中。 + 選擇 **Queries (查詢)** 標籤。 + 將以下變動貼到 **Queries (查詢)** 窗格： ``` mutation addPost { addPost( id: 123 author: "AUTHORNAME" title: "Our first post!" content: "This is our first post." url: "https://aws.amazon.com/appsync/" ) { id author title content url ups downs version } } ``` + 選擇 **Execute query (執行查詢)** (橘色播放按鈕)。 + 新建立文章的結果應該會出現在查詢窗格右側的結果窗格中。其看起來與下列類似： ``` { "data": { "addPost": { "id": "123", "author": "AUTHORNAME", "title": "Our first post!", "content": "This is our first post.", "url": "https://aws.amazon.com/appsync/", "ups": 1, "downs": 0, "version": 1 } } } ``` 以下是發生的情況： + AWS AppSync 收到`addPost`變動請求。 + AWS AppSync 接受了請求和請求映射範本，並產生了請求映射文件。此看起來如下： ``` { "version" : "2017-02-28", "operation" : "PutItem", "key" : { "id" : { "S" : "123" } }, "attributeValues" : { "author": { "S" : "AUTHORNAME" }, "title": { "S" : "Our first post!" }, "content": { "S" : "This is our first post." }, "url": { "S" : "https://aws.amazon.com/appsync/" }, "ups" : { "N" : 1 }, "downs" : { "N" : 0 }, "version" : { "N" : 1 } } } ``` + AWS AppSync 使用請求映射文件來產生和執行 DynamoDB`PutItem` 請求。 + AWS AppSync 取得`PutItem`請求的結果，並將其轉換回 GraphQL 類型。 ``` { "id" : "123", "author": "AUTHORNAME", "title": "Our first post!", "content": "This is our first post.", "url": "https://aws.amazon.com/appsync/", "ups" : 1, "downs" : 0, "version" : 1 } ``` + 透過回應映射文件來進行傳遞，這可讓其以原狀進行傳遞。 + 傳回在 GraphQL 回應中新建立的物件。 ## 設定 getPost 解析程式 (DynamoDB GetItem) 現在，您可以將資料新增至 `AppSyncTutorial-Post`DynamoDB 資料表，您需要設定`getPost`查詢，以便從`AppSyncTutorial-Post`資料表擷取該資料。若要執行此作業，您可以設定另一個解析程式。 + 選擇 **Schema (結構描述)** 標籤。 + 在右側的**資料類型**窗格中，尋找**查詢**類型的 **getPost** 欄位，然後選擇**連接**。 + 在**動作功能表中**，選擇**更新執行時間**，然後選擇**單位解析程式 （僅限 VTL)**。 + 在 **Data source name (資料來源名稱)** 中，選擇 **PostDynamoDBTable**。 + 將以下內容貼到 **Configure the request mapping template (設定請求映射範本)** 區段： ``` { "version" : "2017-02-28", "operation" : "GetItem", "key" : { "id" : $util.dynamodb.toDynamoDBJson($ctx.args.id) } } ``` + 將以下內容貼到 **Configure the response mapping template (設定回應映射範本)** 區段： ``` $utils.toJson($context.result) ``` + 選擇**儲存**。 ### 呼叫 API 以取得文章 現在已設定解析程式， AWS AppSync 知道如何將傳入`getPost`查詢轉譯為 DynamoDB`GetItem` 操作。您現在可以執行查詢，擷取您稍早建立的貼文。 + 選擇 **Queries (查詢)** 標籤。 + 在 **Queries (查詢)** 窗格中，貼入下面內容： ``` query getPost { getPost(id:123) { id author title content url ups downs version } } ``` + 選擇 **Execute query (執行查詢)** (橘色播放按鈕)。 + 從 DynamoDB 擷取的文章應該會出現在查詢窗格右側的結果窗格中。其看起來與下列類似： ``` { "data": { "getPost": { "id": "123", "author": "AUTHORNAME", "title": "Our first post!", "content": "This is our first post.", "url": "https://aws.amazon.com/appsync/", "ups": 1, "downs": 0, "version": 1 } } } ``` 以下是發生的情況： + AWS AppSync 收到`getPost`查詢請求。 + AWS AppSync 接受了請求和請求映射範本，並產生了請求映射文件。此看起來如下： ``` { "version" : "2017-02-28", "operation" : "GetItem", "key" : { "id" : { "S" : "123" } } } ``` + AWS AppSync 使用請求映射文件來產生和執行 DynamoDB GetItem 請求。 + AWS AppSync 取得`GetItem`請求的結果，並將其轉換回 GraphQL 類型。 ``` { "id" : "123", "author": "AUTHORNAME", "title": "Our first post!", "content": "This is our first post.", "url": "https://aws.amazon.com/appsync/", "ups" : 1, "downs" : 0, "version" : 1 } ``` + 透過回應映射文件來進行傳遞，這可讓其以原狀進行傳遞。 + 在回應中傳回擷取的物件。 或者，請採用下列範例： ``` query getPost { getPost(id:123) { id author title } } ``` 如果您的`getPost`查詢只需要 `id`、 `author`和 `title`，您可以將請求映射範本變更為使用投影表達式，以僅指定您希望從 DynamoDB 資料表傳輸的屬性，以避免從 DynamoDB 傳輸不必要的資料 AWS AppSync。例如，請求映射範本可能看起來像下面的程式碼片段： ``` { "version" : "2017-02-28", "operation" : "GetItem", "key" : { "id" : $util.dynamodb.toDynamoDBJson($ctx.args.id) }, "projection" : { "expression" : "#author, id, title", "expressionNames" : { "#author" : "author"} } } ``` ## 建立 updatePost Mutation (DynamoDB UpdateItem) 到目前為止，您可以在 DynamoDB 中建立和擷取`Post`物件。接下來，您會設定新的變動，讓我們能夠更新物件。您可以使用 UpdateItem DynamoDB 操作來執行此作業。 + 選擇 **Schema (結構描述)** 標籤。 + 修改 **Schema (結構描述)** 窗格中的 `Mutation` 類型來新增 `updatePost` 變動，如下所示： ``` type Mutation { updatePost( id: ID!, author: String!, title: String!, content: String!, url: String! ): Post addPost( author: String! title: String! content: String! url: String! ): Post! } ``` + 選擇**儲存**。 + 在右側的**資料類型**窗格中，尋找**變動**類型上新建立的 **updatePost** 欄位，然後選擇**連接**。 + 在**動作功能表中**，選擇**更新執行時間**，然後選擇**單位解析程式 （僅限 VTL)**。 + 在 **Data source name (資料來源名稱)** 中，選擇 **PostDynamoDBTable**。 + 將以下內容貼到 **Configure the request mapping template (設定請求映射範本)** 區段： ``` { "version" : "2017-02-28", "operation" : "UpdateItem", "key" : { "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id) }, "update" : { "expression" : "SET author = :author, title = :title, content = :content, #url = :url ADD version :one", "expressionNames": { "#url" : "url" }, "expressionValues": { ":author" : $util.dynamodb.toDynamoDBJson($context.arguments.author), ":title" : $util.dynamodb.toDynamoDBJson($context.arguments.title), ":content" : $util.dynamodb.toDynamoDBJson($context.arguments.content), ":url" : $util.dynamodb.toDynamoDBJson($context.arguments.url), ":one" : { "N": 1 } } } } ``` **注意：**此解析程式正在使用 DynamoDB UpdateItem，這與 PutItem 操作明顯不同。您只是要求 DynamoDB 更新特定屬性，而不是撰寫整個項目。這是使用 DynamoDB Update Expressions 完成。表達式本身會在 `expression` 區段中的 `update` 欄位中指定。其要求設定 `author`、`title`、`content` 以及 url 屬性，然後遞增 `version` 欄位。要使用的值不會出現在表達式本身；表達式的預留位置名稱開頭為冒號，其會在 `expressionValues` 欄位中加以定義。最後，DynamoDB 保留了無法在 中顯示的單字`expression`。例如，由於 `url` 是保留字，因此若要更新 `url` 欄位，您可以使用名稱預留位置，並在 `expressionNames` 欄位中定義他們。 如需 `UpdateItem` 請求映射的詳細資訊，請參閱 [UpdateItem](aws-appsync-resolver-mapping-template-reference-dynamodb-updateitem.md) 參考文件。如需有關如何撰寫更新表達式的詳細資訊，請參閱 [DynamoDB UpdateExpressions 文件](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html)。 + 將以下內容貼到 **Configure the response mapping template (設定回應映射範本)** 區段： ``` $utils.toJson($context.result) ``` ### 呼叫 API 以更新文章 現在已設定解析程式， AWS AppSync 知道如何將傳入`update`變動轉換為 DynamoDB`Update` 操作。您現在可以執行變動，以更新您之前撰寫的項目。 + 選擇 **Queries (查詢)** 標籤。 + 將以下變動貼到 **Queries (查詢)** 窗格。您也必須將 `id` 引數更新為您先前記下的值。 ``` mutation updatePost { updatePost( id:"123" author: "A new author" title: "An updated author!" content: "Now with updated content!" url: "https://aws.amazon.com/appsync/" ) { id author title content url ups downs version } } ``` + 選擇 **Execute query (執行查詢)** (橘色播放按鈕)。 + DynamoDB 中更新的文章應該會出現在查詢窗格右側的結果窗格中。其看起來與下列類似： ``` { "data": { "updatePost": { "id": "123", "author": "A new author", "title": "An updated author!", "content": "Now with updated content!", "url": "https://aws.amazon.com/appsync/", "ups": 1, "downs": 0, "version": 2 } } } ``` 在此範例中， `ups`和 `downs` 欄位並未修改，因為請求映射範本並未 ask AWS AppSync 和 DynamoDB 對這些欄位執行任何動作。此外， `version` 欄位以 1 遞增，因為您要求 AWS AppSync 和 DynamoDB 將 1 新增至 `version` 欄位。 ## 修改 updatePost 解析程式 (DynamoDB UpdateItem) 這對於 `updatePost` 變動而言是一個好的開始，但有兩個主要的問題： + 如果您只想更新單一欄位，您必須更新所有欄位。 + 如果兩個人同時修改物件，您便可能會失去資訊。 為了解決這些問題，您將會修改 `updatePost` 變動，使其僅修改請求中指定的引數，然後將條件新增到 `UpdateItem` 操作。 1. 選擇 **Schema (結構描述)** 標籤。 1. 在 **Schema (結構描述)** 窗格中，修改 `Mutation` 類型中的 `updatePost` 欄位，以便從 `author`、`title`、`content` 及 `url` 引數中移除驚嘆號，並請確保 `id` 欄位維持原狀。這會使它們變成可選引數。此外，新增必要 `expectedVersion` 引數。 ``` type Mutation { updatePost( id: ID!, author: String, title: String, content: String, url: String, expectedVersion: Int! ): Post addPost( author: String! title: String! content: String! url: String! ): Post! } ``` 1. 選擇**儲存**。 1. 在右側的**資料類型**窗格中，尋找 **Mutation** 類型的 **updatePost** 欄位。 1. 選擇 **PostDynamoDBTable** 以開啟現有的解析程式。 1. 在 **Configure the request mapping template (設定要求映射範本)** 中修改要求映射範本，如下所示： ``` { "version" : "2017-02-28", "operation" : "UpdateItem", "key" : { "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id) }, ## Set up some space to keep track of things you're updating ** #set( $expNames = {} ) #set( $expValues = {} ) #set( $expSet = {} ) #set( $expAdd = {} ) #set( $expRemove = [] ) ## Increment "version" by 1 ** $!{expAdd.put("version", ":one")} $!{expValues.put(":one", { "N" : 1 })} ## Iterate through each argument, skipping "id" and "expectedVersion" ** #foreach( $entry in $context.arguments.entrySet() ) #if( $entry.key != "id" && $entry.key != "expectedVersion" ) #if( (!$entry.value) && ("$!{entry.value}" == "") ) ## If the argument is set to "null", then remove that attribute from the item in DynamoDB ** #set( $discard = ${expRemove.add("#${entry.key}")} ) $!{expNames.put("#${entry.key}", "$entry.key")} #else ## Otherwise set (or update) the attribute on the item in DynamoDB ** $!{expSet.put("#${entry.key}", ":${entry.key}")} $!{expNames.put("#${entry.key}", "$entry.key")} $!{expValues.put(":${entry.key}", { "S" : "${entry.value}" })} #end #end #end ## Start building the update expression, starting with attributes you're going to SET ** #set( $expression = "" ) #if( !${expSet.isEmpty()} ) #set( $expression = "SET" ) #foreach( $entry in $expSet.entrySet() ) #set( $expression = "${expression} ${entry.key} = ${entry.value}" ) #if ( $foreach.hasNext ) #set( $expression = "${expression}," ) #end #end #end ## Continue building the update expression, adding attributes you're going to ADD ** #if( !${expAdd.isEmpty()} ) #set( $expression = "${expression} ADD" ) #foreach( $entry in $expAdd.entrySet() ) #set( $expression = "${expression} ${entry.key} ${entry.value}" ) #if ( $foreach.hasNext ) #set( $expression = "${expression}," ) #end #end #end ## Continue building the update expression, adding attributes you're going to REMOVE ** #if( !${expRemove.isEmpty()} ) #set( $expression = "${expression} REMOVE" ) #foreach( $entry in $expRemove ) #set( $expression = "${expression} ${entry}" ) #if ( $foreach.hasNext ) #set( $expression = "${expression}," ) #end #end #end ## Finally, write the update expression into the document, along with any expressionNames and expressionValues ** "update" : { "expression" : "${expression}" #if( !${expNames.isEmpty()} ) ,"expressionNames" : $utils.toJson($expNames) #end #if( !${expValues.isEmpty()} ) ,"expressionValues" : $utils.toJson($expValues) #end }, "condition" : { "expression" : "version = :expectedVersion", "expressionValues" : { ":expectedVersion" : $util.dynamodb.toDynamoDBJson($context.arguments.expectedVersion) } } } ``` 1. 選擇**儲存**。 此範本是更為複雜的範例。它示範映射範本的強大功能和靈活性。它會循環使用所有引數，但會略過 `id` 和 `expectedVersion`。如果引數設為某個項目，則其 ask AWS AppSync 和 DynamoDB 會更新 DynamoDB 中物件上的該屬性。如果屬性設定為 null，則其 asked AWS AppSync 和 DynamoDB 會從後置物件中移除該屬性。若未指定引數，它將會保留該屬性。它會增量 `version` 欄位。 另外，還有新的 `condition` 區段。條件表達式可讓您 tell AWS AppSync 和 DynamoDB，根據在執行操作之前已在 DynamoDB 中的物件狀態，請求是否應成功。在此情況下，只有在 DynamoDB 中目前項目`version`的欄位完全符合`expectedVersion`引數時，您才希望`UpdateItem`請求成功。 如需條件表達式的詳細資訊，請參閱[條件表達式](aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.md)參考文件。 ### 呼叫 API 以更新文章 讓我們嘗試使用新解析程式來更新 `Post` 物件： + 選擇 **Queries (查詢)** 標籤。 + 將以下變動貼到 **Queries (查詢)** 窗格。您也必須將 `id` 引數更新為您先前記下的值。 ``` mutation updatePost { updatePost( id:123 title: "An empty story" content: null expectedVersion: 2 ) { id author title content url ups downs version } } ``` + 選擇 **Execute query (執行查詢)** (橘色播放按鈕)。 + DynamoDB 中更新的文章應該會出現在查詢窗格右側的結果窗格中。其看起來與下列類似： ``` { "data": { "updatePost": { "id": "123", "author": "A new author", "title": "An empty story", "content": null, "url": "https://aws.amazon.com/appsync/", "ups": 1, "downs": 0, "version": 3 } } } ``` 在此請求中，您要求 AWS AppSync 和 DynamoDB 僅更新 `title`和 `content` 欄位。它會將所有其他欄位單獨保留 (除了遞增 `version` 欄位)。您將 `title` 屬性設定為新的值，並從文章中移除 `content` 屬性。`author`、`url`、`ups` 和 `downs` 欄位維持原狀。 嘗試再次執行變動要求，讓要求維持原狀。您應該會看到類似以下的回應： ``` { "data": { "updatePost": null }, "errors": [ { "path": [ "updatePost" ], "data": { "id": "123", "author": "A new author", "title": "An empty story", "content": null, "url": "https://aws.amazon.com/appsync/", "ups": 1, "downs": 0, "version": 3 }, "errorType": "DynamoDB:ConditionalCheckFailedException", "locations": [ { "line": 2, "column": 3 } ], "message": "The conditional request failed (Service: AmazonDynamoDBv2; Status Code: 400; Error Code: ConditionalCheckFailedException; Request ID: ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ)" } ] } ``` 條件表達式評估為「false」，因此要求失敗： + 第一次執行請求時，DynamoDB 中文章的 `version` 欄位值為 `2`，符合 `expectedVersion`引數。請求成功，這表示 `version` 欄位已在 DynamoDB 中遞增至 `3`。 + 第二次執行請求時，DynamoDB 中文章的 `version` 欄位值為 `3`，這不符合引`expectedVersion`數。 此模式通常稱為*樂觀鎖定*。 an AWS AppSync DynamoDB 解析程式的一項功能是傳回 DynamoDB 中貼文物件的目前值。您可以在 GraphQL 回應的 `data` 區段 `errors` 欄位中找到此值。您的應用程式可以使用這些資訊來決定繼續執行的方式。在這種情況下，您可以看到 DynamoDB 中物件`version`的欄位設定為 `3`，因此您只要將`expectedVersion`引數更新為 `3`，請求就會再次成功。 如需有關處理條件檢查錯誤的詳細資訊，請參閱[條件表達式](aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.md)映射範本參考文件。 ## 建立 upvotePost 和 downvotePost 變動 (DynamoDB UpdateItem) `Post` 類型具有 `ups` 和 `downs` 欄位，可記錄贊同數和不贊同數，但是到目前為止，API 不會讓我們使用它們來執行任何動作。讓我們新增一些變動來對文章表示贊同與不贊同。 + 選擇 **Schema (結構描述)** 標籤。 + 修改 **Schema (結構描述)** 窗格中的 `Mutation` 類型以新增 `upvotePost` 和 `downvotePost` 變動，如下所示： ``` type Mutation { upvotePost(id: ID!): Post downvotePost(id: ID!): Post updatePost( id: ID!, author: String, title: String, content: String, url: String, expectedVersion: Int! ): Post addPost( author: String!, title: String!, content: String!, url: String! ): Post! } ``` + 選擇**儲存**。 + 在右側的**資料類型**窗格中，尋找**變動**類型上新建立的 **upvotePost** 欄位，然後選擇**連接**。 + 在**動作功能表中**，選擇**更新執行時間**，然後選擇**單位解析程式 （僅限 VTL)**。 + 在 **Data source name (資料來源名稱)** 中，選擇 **PostDynamoDBTable**。 + 將以下內容貼到 **Configure the request mapping template (設定請求映射範本)** 區段： ``` { "version" : "2017-02-28", "operation" : "UpdateItem", "key" : { "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id) }, "update" : { "expression" : "ADD ups :plusOne, version :plusOne", "expressionValues" : { ":plusOne" : { "N" : 1 } } } } ``` + 將以下內容貼到 **Configure the response mapping template (設定回應映射範本)** 區段： ``` $utils.toJson($context.result) ``` + 選擇**儲存**。 + 在右側的**資料類型**窗格中，尋找**變動**類型上新建立`downvotePost`的欄位，然後選擇**連接**。 + 在 **Data source name (資料來源名稱)** 中，選擇 **PostDynamoDBTable**。 + 將以下內容貼到 **Configure the request mapping template (設定請求映射範本)** 區段： ``` { "version" : "2017-02-28", "operation" : "UpdateItem", "key" : { "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id) }, "update" : { "expression" : "ADD downs :plusOne, version :plusOne", "expressionValues" : { ":plusOne" : { "N" : 1 } } } } ``` + 將以下內容貼到 **Configure the response mapping template (設定回應映射範本)** 區段： ``` $utils.toJson($context.result) ``` + 選擇**儲存**。 ### 呼叫 API 來對文章表達贊同或不贊同 現在已設定新的解析程式， AWS AppSync 知道如何將傳入`upvotePost`或`downvote`變動轉換為 DynamoDB UpdateItem 操作。您現在可以執行變動，對您之前建立的文章表達贊同或不贊同。 + 選擇 **Queries (查詢)** 標籤。 + 將以下變動貼到 **Queries (查詢)** 窗格。您也必須將 `id` 引數更新為您先前記下的值。 ``` mutation votePost { upvotePost(id:123) { id author title content url ups downs version } } ``` + 選擇 **Execute query (執行查詢)** (橘色播放按鈕)。 + 文章會在 DynamoDB 中更新，並應出現在查詢窗格右側的結果窗格中。其看起來與下列類似： ``` { "data": { "upvotePost": { "id": "123", "author": "A new author", "title": "An empty story", "content": null, "url": "https://aws.amazon.com/appsync/", "ups": 6, "downs": 0, "version": 4 } } } ``` + 再選擇幾次 **Execute query (執行查詢)**。您應查看在每次執行查詢時以 1 為單位而遞增的 `ups` 和 `version` 欄位。 + 變更查詢以呼叫 `downvotePost` 變動，如下所示： ``` mutation votePost { downvotePost(id:123) { id author title content url ups downs version } } ``` + 選擇 **Execute query (執行查詢)** (橘色播放按鈕)。此時，您應查看在每次執行查詢時以 1 為單位而遞增的 `downs` 和 `version` 欄位。 ``` { "data": { "downvotePost": { "id": "123", "author": "A new author", "title": "An empty story", "content": null, "url": "https://aws.amazon.com/appsync/", "ups": 6, "downs": 4, "version": 12 } } } ``` ## 設定 deletePost Resolver (DynamoDB DeleteItem) 您要設定的下一個變動是刪除貼文。您將使用 `DeleteItem` DynamoDB 操作來執行此操作。 + 選擇 **Schema (結構描述)** 標籤。 + 修改 **Schema (結構描述)** 窗格中的 `Mutation` 類型來新增 `deletePost` 變動，如下所示： ``` type Mutation { deletePost(id: ID!, expectedVersion: Int): Post upvotePost(id: ID!): Post downvotePost(id: ID!): Post updatePost( id: ID!, author: String, title: String, content: String, url: String, expectedVersion: Int! ): Post addPost( author: String!, title: String!, content: String!, url: String! ): Post! } ``` 這次您將 `expectedVersion` 欄位設為選用，稍後在您新增要求映射範本時，將對此進行說明。 + 選擇**儲存**。 + 在右側的**資料類型**窗格中，尋找**變動**類型上新建立的**刪除**欄位，然後選擇**連接**。 + 在**動作功能表中**，選擇**更新執行時間**，然後選擇**單位解析程式 （僅限 VTL)**。 + 在 **Data source name (資料來源名稱)** 中，選擇 **PostDynamoDBTable**。 + 將以下內容貼到 **Configure the request mapping template (設定請求映射範本)** 區段： ``` { "version" : "2017-02-28", "operation" : "DeleteItem", "key": { "id": $util.dynamodb.toDynamoDBJson($context.arguments.id) } #if( $context.arguments.containsKey("expectedVersion") ) ,"condition" : { "expression" : "attribute_not_exists(id) OR version = :expectedVersion", "expressionValues" : { ":expectedVersion" : $util.dynamodb.toDynamoDBJson($context.arguments.expectedVersion) } } #end } ``` **注意：**`expectedVersion` 引數為可選引數。如果發起人在請求中設定`expectedVersion`引數，則範本會新增一個條件，只有在項目已刪除或 DynamoDB 中的文章`version`屬性完全符合 時，才會允許`DeleteItem`請求成功`expectedVersion`。如果省略，將不會在 `DeleteItem` 要求中指定條件表達式。無論 的值為何`version`，或 DynamoDB 中是否存在該項目，它都會成功。 + 將以下內容貼到 **Configure the response mapping template (設定回應映射範本)** 區段： ``` $utils.toJson($context.result) ``` **注意：**即使您正在刪除某個項目，如果該項目尚未刪除，您仍然可以傳回已刪除的項目。 + 選擇**儲存**。 如需有關 `DeleteItem` 要求映射的詳細資訊，請參閱 [DeleteItem](aws-appsync-resolver-mapping-template-reference-dynamodb-deleteitem.md) 參考文件。 ### 呼叫 API 以刪除文章 現在已設定解析程式， AWS AppSync 知道如何將傳入`delete`變動轉換為 DynamoDB`DeleteItem` 操作。您現在可以執行變動以在資料表中刪除項目。 + 選擇 **Queries (查詢)** 標籤。 + 將以下變動貼到 **Queries (查詢)** 窗格。您也必須將 `id` 引數更新為您先前記下的值。 ``` mutation deletePost { deletePost(id:123) { id author title content url ups downs version } } ``` + 選擇 **Execute query (執行查詢)** (橘色播放按鈕)。 + 文章會從 DynamoDB 刪除。請注意， AWS AppSync 會傳回從 DynamoDB 刪除的項目值，該值應該會出現在查詢窗格右側的結果窗格中。其看起來與下列類似： ``` { "data": { "deletePost": { "id": "123", "author": "A new author", "title": "An empty story", "content": null, "url": "https://aws.amazon.com/appsync/", "ups": 6, "downs": 4, "version": 12 } } } ``` 如果對 `deletePost` 的呼叫實際上是從 DynamoDB 遭到刪除的呼叫，則只會傳回值。 + 再次選擇 **Execute query (執行查詢)**。 + 此呼叫仍會成功，但不會傳回任何值。 ``` { "data": { "deletePost": null } } ``` 現在讓我們嘗試刪除文章，但這次是指定 `expectedValue`。首先，您需要建立新文章，因為您刪除的正好是您到目前為止所用的文章。 + 將以下變動貼到 **Queries (查詢)** 窗格： ``` mutation addPost { addPost( id:123 author: "AUTHORNAME" title: "Our second post!" content: "A new post." url: "https://aws.amazon.com/appsync/" ) { id author title content url ups downs version } } ``` + 選擇 **Execute query (執行查詢)** (橘色播放按鈕)。 + 新建立文章的結果應該會出現在查詢窗格右側的結果窗格中。請記下新建立的物件的 `id`，因為您很快就會用到它。其看起來與下列類似： ``` { "data": { "addPost": { "id": "123", "author": "AUTHORNAME", "title": "Our second post!", "content": "A new post.", "url": "https://aws.amazon.com/appsync/", "ups": 1, "downs": 0, "version": 1 } } } ``` 現在讓我們嘗試刪除該文章，但我們將錯誤的值放入 `expectedVersion`： + 將以下變動貼到 **Queries (查詢)** 窗格。您也必須將 `id` 引數更新為您先前記下的值。 ``` mutation deletePost { deletePost( id:123 expectedVersion: 9999 ) { id author title content url ups downs version } } ``` + 選擇 **Execute query (執行查詢)** (橘色播放按鈕)。 ``` { "data": { "deletePost": null }, "errors": [ { "path": [ "deletePost" ], "data": { "id": "123", "author": "AUTHORNAME", "title": "Our second post!", "content": "A new post.", "url": "https://aws.amazon.com/appsync/", "ups": 1, "downs": 0, "version": 1 }, "errorType": "DynamoDB:ConditionalCheckFailedException", "locations": [ { "line": 2, "column": 3 } ], "message": "The conditional request failed (Service: AmazonDynamoDBv2; Status Code: 400; Error Code: ConditionalCheckFailedException; Request ID: ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ)" } ] } ``` 請求失敗，因為條件表達式評估為 false：DynamoDB 中文章 `version` 的值不符合引數中`expectedValue`指定的 。會在 GraphQL 回應 `data` 區段中 `errors` 欄位傳回物件的目前值。 + 重試要求，但更正 `expectedVersion`： ``` mutation deletePost { deletePost( id:123 expectedVersion: 1 ) { id author title content url ups downs version } } ``` + 選擇 **Execute query (執行查詢)** (橘色播放按鈕)。 + 這次請求成功，並傳回從 DynamoDB 刪除的值： ``` { "data": { "deletePost": { "id": "123", "author": "AUTHORNAME", "title": "Our second post!", "content": "A new post.", "url": "https://aws.amazon.com/appsync/", "ups": 1, "downs": 0, "version": 1 } } } ``` + 再次選擇 **Execute query (執行查詢)**。 + 呼叫仍然成功，但這次不會傳回任何值，因為文章已在 DynamoDB 中刪除。 ``` { "data": { "deletePost": null } } ``` ## 設定 allPost 解析程式 (DynamoDB Scan) 到目前為止，如果您知道要尋找之每個文章的 `id`，API 才有用。讓我們新增新的解析程式，傳回資料表中的所有文章。 + 選擇 **Schema (結構描述)** 標籤。 + 修改 **Schema (結構描述)** 窗格中的 `Query` 類型以新增 `allPost` 查詢，如下所示： ``` type Query { allPost(count: Int, nextToken: String): PaginatedPosts! getPost(id: ID): Post } ``` + 新增 `PaginationPosts` 類型： ``` type PaginatedPosts { posts: [Post!]! nextToken: String } ``` + 選擇**儲存**。 + 在右側的**資料類型**窗格中，尋找**查詢**類型上新建立的 **allPost** 欄位，然後選擇**連接**。 + 在**動作功能表中**，選擇**更新執行時間**，然後選擇**單位解析程式 （僅限 VTL)**。 + 在 **Data source name (資料來源名稱)** 中，選擇 **PostDynamoDBTable**。 + 將以下內容貼到 **Configure the request mapping template (設定請求映射範本)** 區段： ``` { "version" : "2017-02-28", "operation" : "Scan" #if( ${context.arguments.count} ) ,"limit": $util.toJson($context.arguments.count) #end #if( ${context.arguments.nextToken} ) ,"nextToken": $util.toJson($context.arguments.nextToken) #end } ``` 此解析程式有兩個選用引數：`count` 會指定單一呼叫中傳回的項目上限數，`nextToken` 可用來擷取下一組結果 (稍後您將顯示 `nextToken` 值來自何處)。 + 將以下內容貼到 **Configure the response mapping template (設定回應映射範本)** 區段： ``` { "posts": $utils.toJson($context.result.items) #if( ${context.result.nextToken} ) ,"nextToken": $util.toJson($context.result.nextToken) #end } ``` **注意：**到目前為止，此回應映射範本與所有其他範本皆不同。`allPost` 查詢結果是 `PaginatedPosts`，其中包含文章清單和分頁字符。此物件的形狀與從 the AWS AppSync DynamoDB Resolver 傳回的物件不同：文章清單在 AWS AppSync DynamoDB Resolver 結果`items`中稱為 ，但在 `posts`中稱為 `PaginatedPosts`。 + 選擇**儲存**。 如需有關 `Scan` 要求映射的詳細資訊，請參閱[掃描](aws-appsync-resolver-mapping-template-reference-dynamodb-scan.md)參考文件。 ### 呼叫 API 以掃描所有文章 現在已設定解析程式， AWS AppSync 知道如何將傳入`allPost`查詢轉譯為 DynamoDB`Scan` 操作。您現在可以掃描資料表來擷取所有文章。 在您可以嘗試之前，您必須將一些資料填入資料表，因為您已刪除目前為止所使用的項目。 + 選擇 **Queries (查詢)** 標籤。 + 將以下變動貼到 **Queries (查詢)** 窗格： ``` mutation addPost { post1: addPost(id:1 author: "AUTHORNAME" title: "A series of posts, Volume 1" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title } post2: addPost(id:2 author: "AUTHORNAME" title: "A series of posts, Volume 2" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title } post3: addPost(id:3 author: "AUTHORNAME" title: "A series of posts, Volume 3" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title } post4: addPost(id:4 author: "AUTHORNAME" title: "A series of posts, Volume 4" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title } post5: addPost(id:5 author: "AUTHORNAME" title: "A series of posts, Volume 5" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title } post6: addPost(id:6 author: "AUTHORNAME" title: "A series of posts, Volume 6" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title } post7: addPost(id:7 author: "AUTHORNAME" title: "A series of posts, Volume 7" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title } post8: addPost(id:8 author: "AUTHORNAME" title: "A series of posts, Volume 8" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title } post9: addPost(id:9 author: "AUTHORNAME" title: "A series of posts, Volume 9" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title } } ``` + 選擇 **Execute query (執行查詢)** (橘色播放按鈕)。 現在，讓我們來掃描資料表，一次會傳回五個結果。 + 將以下查詢貼到 **Queries (查詢)** 窗格中： ``` query allPost { allPost(count: 5) { posts { id title } nextToken } } ``` + 選擇 **Execute query (執行查詢)** (橘色播放按鈕)。 + 前五篇文章應該會出現在查詢窗格右側的結果窗格中。其看起來與下列類似： ``` { "data": { "allPost": { "posts": [ { "id": "5", "title": "A series of posts, Volume 5" }, { "id": "1", "title": "A series of posts, Volume 1" }, { "id": "6", "title": "A series of posts, Volume 6" }, { "id": "9", "title": "A series of posts, Volume 9" }, { "id": "7", "title": "A series of posts, Volume 7" } ], "nextToken": "eyJ2ZXJzaW9uIjoxLCJ0b2tlbiI6IkFRSUNBSGo4eHR0RG0xWXhUa1F0cEhXMEp1R3B0M1B3eThOSmRvcG9ad2RHYjI3Z0lnRkJEdXdUK09hcnovRGhNTGxLTGdMUEFBQUI1akNDQWVJR0NTcUdTSWIzRFFFSEJxQ0NBZE13Z2dIUEFnRUFNSUlCeUFZSktvWklodmNOQVFjQk1CNEdDV0NHU0FGbEF3UUJMakFSQkF6ajFodkhKU1paT1pncTRaUUNBUkNBZ2dHWnJiR1dQWGxkMDB1N0xEdGY4Z2JsbktzRjRua1VCcks3TFJLcjZBTFRMeGFwVGJZMDRqOTdKVFQyYVRwSzdzbVdtNlhWWFVCTnFIOThZTzBWZHVkdDI2RlkxMHRqMDJ2QTlyNWJTUWpTbWh6NE5UclhUMG9KZWJSQ2JJbXBlaDRSVlg0Tis0WTVCN1IwNmJQWWQzOVhsbTlUTjBkZkFYMVErVCthaXZoNE5jMk50RitxVmU3SlJ5WmpzMEFkSGduM3FWd2VrOW5oeFVVd3JlK1loUks5QkRzemdiMDlmZmFPVXpzaFZ4cVJRbC93RURlOTcrRmVJdXZNby9NZ1F6dUdNbFRyalpNR3FuYzZBRnhwa0VlZTFtR0FwVDFISElUZlluakptYklmMGUzUmcxbVlnVHVSbDh4S0trNmR0QVoraEhLVDhuNUI3VnF4bHRtSnlNUXBrZGl6KzkyL3VzNDl4OWhrMnVxSW01ZFFwMjRLNnF0dm9ZK1BpdERuQTc5djhzb0grVytYT3VuQ2NVVDY4TVZ1Wk5KYkRuSEFSSEVlaTlVNVBTelU5RGZ6d2pPdmhqWDNJMWhwdWUrWi83MDVHVjlPQUxSTGlwZWZPeTFOZFhwZTdHRDZnQW00bUJUK2c1eC9Ec3ZDbWVnSDFDVXRTdHVuU1ZFa2JpZytQRC9oMUwyRTNqSHhVQldaa28yU256WUc0cG0vV1RSWkFVZHZuQT09In0=" } } } ``` 您取得五個結果以及 `nextToken`，您可以用它來取得下一組結果。 + 更新 `allPost` 查詢以包括來自之前結果組的 `nextToken`： ``` query allPost { allPost( count: 5 nextToken: "eyJ2ZXJzaW9uIjoxLCJ0b2tlbiI6IkFRSUNBSGo4eHR0RG0xWXhUa1F0cEhXMEp1R3B0M1B3eThOSmRvcG9ad2RHYjI3Z0lnRlluNktJRWl6V0ZlR3hJOVJkaStrZUFBQUI1akNDQWVJR0NTcUdTSWIzRFFFSEJxQ0NBZE13Z2dIUEFnRUFNSUlCeUFZSktvWklodmNOQVFjQk1CNEdDV0NHU0FGbEF3UUJMakFSQkF5cW8yUGFSZThnalFpemRCTUNBUkNBZ2dHWk1JODhUNzhIOFVUZGtpdFM2ZFluSWRyVDg4c2lkN1RjZzB2d1k3VGJTTWpSQ2U3WjY3TkUvU2I1dWNETUdDMmdmMHErSGJSL0pteGRzYzVEYnE1K3BmWEtBdU5jSENJdWNIUkJ0UHBPWVdWdCtsS2U5L1pNcWdocXhrem1RaXI1YnIvQkt6dU5hZmJCdE93NmtoM2Jna1BKM0RjWWhpMFBGbmhMVGg4TUVGSjBCcXg3RTlHR1V5N0tUS0JLZlV3RjFQZ0JRREdrNzFYQnFMK2R1S2IrVGtZZzVYMjFrc3NyQmFVTmNXZmhTeXE0ZUJHSWhqZWQ5c3VKWjBSSTc2ZnVQdlZkR3FLNENjQmxHYXhpekZnK2pKK1FneEU1SXduRTNYYU5TR0I4QUpmamR2bU1wbUk1SEdvWjlMUUswclczbG14RDRtMlBsaTNLaEVlcm9pem5zcmdINFpvcXIrN2ltRDN3QkJNd3BLbGQzNjV5Nnc4ZnMrK2FnbTFVOUlKOFFrOGd2bEgySHFROHZrZXBrMWlLdWRIQ25LaS9USnBlMk9JeEVPazVnRFlzRTRUU09HUlVJTkxYY2MvdW1WVEpBMUthV2hWTlAvdjNlSnlZQUszbWV6N2h5WHVXZ1BkTVBNWERQdTdjVnVRa3EwK3NhbGZOd2wvSUx4bHNyNDVwTEhuVFpyRWZvVlV1bXZ5S2VKY1RUU1lET05hM1NwWEd2UT09In0=" ) { posts { id author } nextToken } } ``` + 選擇 **Execute query (執行查詢)** (橘色播放按鈕)。 + 剩餘的四篇文章應該會出現在查詢窗格右側的結果窗格中。在這組結果中沒有 `nextToken`，因為您已翻遍了所有九篇文章，已經沒有剩餘的文章。其看起來與下列類似： ``` { "data": { "allPost": { "posts": [ { "id": "2", "title": "A series of posts, Volume 2" }, { "id": "3", "title": "A series of posts, Volume 3" }, { "id": "4", "title": "A series of posts, Volume 4" }, { "id": "8", "title": "A series of posts, Volume 8" } ], "nextToken": null } } } ``` ## 設定 allPostsByAuthor 解析程式 (DynamoDB 查詢） 除了掃描 DynamoDB 的所有文章之外，您也可以查詢 DynamoDB 以擷取特定作者建立的文章。您先前建立的 DynamoDB 資料表已有`GlobalSecondaryIndex`稱為 的 `author-index` ，您可以使用 DynamoDB`Query` 操作來擷取特定作者建立的所有文章。 + 選擇 **Schema (結構描述)** 標籤。 + 修改 **Schema (結構描述)** 窗格中的 `Query` 類型以新增 `allPostsByAuthor` 查詢，如下所示： ``` type Query { allPostsByAuthor(author: String!, count: Int, nextToken: String): PaginatedPosts! allPost(count: Int, nextToken: String): PaginatedPosts! getPost(id: ID): Post } ``` **注意：**這會使用與您在 `allPost` 查詢中使用的相同 `PaginatedPosts` 類型。 + 選擇**儲存**。 + 在右側的**資料類型**窗格中，尋找**查詢**類型上新建立的 **allPostsByAuthor** 欄位，然後選擇**連接**。 + 在**動作功能表中**，選擇**更新執行時間**，然後選擇**單位解析程式 （僅限 VTL)**。 + 在 **Data source name (資料來源名稱)** 中，選擇 **PostDynamoDBTable**。 + 將以下內容貼到 **Configure the request mapping template (設定請求映射範本)** 區段： ``` { "version" : "2017-02-28", "operation" : "Query", "index" : "author-index", "query" : { "expression": "author = :author", "expressionValues" : { ":author" : $util.dynamodb.toDynamoDBJson($context.arguments.author) } } #if( ${context.arguments.count} ) ,"limit": $util.toJson($context.arguments.count) #end #if( ${context.arguments.nextToken} ) ,"nextToken": "${context.arguments.nextToken}" #end } ``` 如同 `allPost` 解析程式，此解析程式有兩個可選引數：`count`，其會指定項目的上限數，以在單一呼叫中傳回，以及 `nextToken`，其可用來擷取接下來的結果組 (您可從先前的呼叫中取得 `nextToken` 值)。 + 將以下內容貼到 **Configure the response mapping template (設定回應映射範本)** 區段： ``` { "posts": $utils.toJson($context.result.items) #if( ${context.result.nextToken} ) ,"nextToken": $util.toJson($context.result.nextToken) #end } ``` **注意**：這是與您在 `allPost` 解析程式中所使用的相同回應映射範本。 + 選擇**儲存**。 如需有關 `Query` 要求映射的詳細資訊，請參閱[查詢](aws-appsync-resolver-mapping-template-reference-dynamodb-query.md)參考文件。 ### 呼叫 API 來查詢某個作者的所有文章 現在已設定解析程式， AWS AppSync 知道如何針對`author-index`索引將傳入`allPostsByAuthor`變動轉換為 DynamoDB`Query` 操作。您現在可以查詢資料表以擷取特定作者的所有文章。 在這麼做之前，讓我們再將一些文章填入資料表，因為目前為止每篇文章的作者都一樣。 + 選擇 **Queries (查詢)** 標籤。 + 將以下變動貼到 **Queries (查詢)** 窗格： ``` mutation addPost { post1: addPost(id:10 author: "Nadia" title: "The cutest dog in the world" content: "So cute. So very, very cute." url: "https://aws.amazon.com/appsync/" ) { author, title } post2: addPost(id:11 author: "Nadia" title: "Did you know...?" content: "AppSync works offline?" url: "https://aws.amazon.com/appsync/" ) { author, title } post3: addPost(id:12 author: "Steve" title: "I like GraphQL" content: "It's great" url: "https://aws.amazon.com/appsync/" ) { author, title } } ``` + 選擇 **Execute query (執行查詢)** (橘色播放按鈕)。 現在，讓我們查詢資料表，傳回 `Nadia` 撰寫的所有文章。 + 將以下查詢貼到 **Queries (查詢)** 窗格中： ``` query allPostsByAuthor { allPostsByAuthor(author: "Nadia") { posts { id title } nextToken } } ``` + 選擇 **Execute query (執行查詢)** (橘色播放按鈕)。 + `Nadia` 撰寫的所有文章應該會出現在查詢窗格右側的結果窗格中。其看起來與下列類似： ``` { "data": { "allPostsByAuthor": { "posts": [ { "id": "10", "title": "The cutest dog in the world" }, { "id": "11", "title": "Did you know...?" } ], "nextToken": null } } } ``` 分頁適用於 `Query`，如同它適用於 `Scan`。例如，讓我們查詢 `AUTHORNAME` 的所有文章，一次取得五篇。 + 將以下查詢貼到 **Queries (查詢)** 窗格中： ``` query allPostsByAuthor { allPostsByAuthor( author: "AUTHORNAME" count: 5 ) { posts { id title } nextToken } } ``` + 選擇 **Execute query (執行查詢)** (橘色播放按鈕)。 + `AUTHORNAME` 撰寫的所有文章應該會出現在查詢窗格右側的結果窗格中。其看起來與下列類似： ``` { "data": { "allPostsByAuthor": { "posts": [ { "id": "6", "title": "A series of posts, Volume 6" }, { "id": "4", "title": "A series of posts, Volume 4" }, { "id": "2", "title": "A series of posts, Volume 2" }, { "id": "7", "title": "A series of posts, Volume 7" }, { "id": "1", "title": "A series of posts, Volume 1" } ], "nextToken": "eyJ2ZXJzaW9uIjoxLCJ0b2tlbiI6IkFRSUNBSGo4eHR0RG0xWXhUa1F0cEhXMEp1R3B0M1B3eThOSmRvcG9ad2RHYjI3Z0lnSExqRnVhVUR3ZUhEZ2QzNGJ2QlFuY0FBQUNqekNDQW9zR0NTcUdTSWIzRFFFSEJxQ0NBbnd3Z2dKNEFnRUFNSUlDY1FZSktvWklodmNOQVFjQk1CNEdDV0NHU0FGbEF3UUJMakFSQkF5Qkg4Yk1obW9LVEFTZHM3SUNBUkNBZ2dKQ3dISzZKNlJuN3pyYUVKY1pWNWxhSkNtZW1KZ0F5N1dhZkc2UEdTNHpNQzJycTkwZHFJTFV6Z25wck9Gd3pMS3VOQ2JvUXc3VDI5eCtnVExIbGg4S3BqbzB1YjZHQ3FwcDhvNDVmMG9JbDlmdS9JdjNXcFNNSXFKTXZ1MEVGVWs1VzJQaW5jZGlUaVRtZFdYWlU1bkV2NkgyRFBRQWZYYlNnSmlHSHFLbmJZTUZZM0FTdmRIL0hQaVZBb1RCMk1YZkg0eGJOVTdEbjZtRFNhb2QwbzdHZHJEWDNtODQ1UXBQUVNyUFhHemY0WDkyajhIdlBCSWE4Smcrb0RxbHozUVQ5N2FXUXdYWWU2S0h4emI1ejRITXdEdXEyRDRkYzhoMi9CbW10MzRMelVGUVIyaExSZGRaZ0xkdzF5cHJZdFZwY3dEc1d4UURBTzdOcjV2ZEp4VVR2TVhmODBRSnp1REhXREpTVlJLdDJwWmlpaXhXeGRwRmNod1BzQ3d2aVBqMGwrcWFFWU1jMXNQbENkVkFGem43VXJrSThWbS8wWHlwR2xZb3BSL2FkV0xVekgrbGMrYno1ZEM2SnVLVXdtY1EyRXlZeDZiS0Izbi9YdUViWGdFeU5PMWZTdE1rRlhyWmpvMVpzdlYyUFRjMzMrdEs0ZDhkNkZrdjh5VVR6WHhJRkxIaVNsOUx6VVdtT3BCaWhrTFBCT09jcXkyOHh1UmkzOEM3UFRqMmN6c3RkOUo1VUY0azBJdUdEbVZzM2xjdWg1SEJjYThIeXM2aEpvOG1HbFpMNWN6R2s5bi8vRE1EbDY3RlJraG5QNFNhSDBpZGI5VFEvMERLeFRBTUdhcWpPaEl5ekVqd2ZDQVJleFdlbldyOGlPVkhScDhGM25WZVdvbFRGK002N0xpdi9XNGJXdDk0VEg3b0laUU5lYmZYKzVOKy9Td25Hb1dyMTlWK0pEb2lIRVFLZ1cwMWVuYjZKUXo5Slh2Tm95ZzF3RnJPVmxGc2xwNlRHa1BlN2Rnd2IrWT0ifQ==" } } } ``` + 使用之前查詢傳回的值更新 `nextToken` 引數，如下所示： ``` query allPostsByAuthor { allPostsByAuthor( author: "AUTHORNAME" count: 5 nextToken: "eyJ2ZXJzaW9uIjoxLCJ0b2tlbiI6IkFRSUNBSGo4eHR0RG0xWXhUa1F0cEhXMEp1R3B0M1B3eThOSmRvcG9ad2RHYjI3Z0lnSExqRnVhVUR3ZUhEZ2QzNGJ2QlFuY0FBQUNqekNDQW9zR0NTcUdTSWIzRFFFSEJxQ0NBbnd3Z2dKNEFnRUFNSUlDY1FZSktvWklodmNOQVFjQk1CNEdDV0NHU0FGbEF3UUJMakFSQkF5Qkg4Yk1obW9LVEFTZHM3SUNBUkNBZ2dKQ3dISzZKNlJuN3pyYUVKY1pWNWxhSkNtZW1KZ0F5N1dhZkc2UEdTNHpNQzJycTkwZHFJTFV6Z25wck9Gd3pMS3VOQ2JvUXc3VDI5eCtnVExIbGg4S3BqbzB1YjZHQ3FwcDhvNDVmMG9JbDlmdS9JdjNXcFNNSXFKTXZ1MEVGVWs1VzJQaW5jZGlUaVRtZFdYWlU1bkV2NkgyRFBRQWZYYlNnSmlHSHFLbmJZTUZZM0FTdmRIL0hQaVZBb1RCMk1YZkg0eGJOVTdEbjZtRFNhb2QwbzdHZHJEWDNtODQ1UXBQUVNyUFhHemY0WDkyajhIdlBCSWE4Smcrb0RxbHozUVQ5N2FXUXdYWWU2S0h4emI1ejRITXdEdXEyRDRkYzhoMi9CbW10MzRMelVGUVIyaExSZGRaZ0xkdzF5cHJZdFZwY3dEc1d4UURBTzdOcjV2ZEp4VVR2TVhmODBRSnp1REhXREpTVlJLdDJwWmlpaXhXeGRwRmNod1BzQ3d2aVBqMGwrcWFFWU1jMXNQbENkVkFGem43VXJrSThWbS8wWHlwR2xZb3BSL2FkV0xVekgrbGMrYno1ZEM2SnVLVXdtY1EyRXlZeDZiS0Izbi9YdUViWGdFeU5PMWZTdE1rRlhyWmpvMVpzdlYyUFRjMzMrdEs0ZDhkNkZrdjh5VVR6WHhJRkxIaVNsOUx6VVdtT3BCaWhrTFBCT09jcXkyOHh1UmkzOEM3UFRqMmN6c3RkOUo1VUY0azBJdUdEbVZzM2xjdWg1SEJjYThIeXM2aEpvOG1HbFpMNWN6R2s5bi8vRE1EbDY3RlJraG5QNFNhSDBpZGI5VFEvMERLeFRBTUdhcWpPaEl5ekVqd2ZDQVJleFdlbldyOGlPVkhScDhGM25WZVdvbFRGK002N0xpdi9XNGJXdDk0VEg3b0laUU5lYmZYKzVOKy9Td25Hb1dyMTlWK0pEb2lIRVFLZ1cwMWVuYjZKUXo5Slh2Tm95ZzF3RnJPVmxGc2xwNlRHa1BlN2Rnd2IrWT0ifQ==" ) { posts { id title } nextToken } } ``` + 選擇 **Execute query (執行查詢)** (橘色播放按鈕)。 + `AUTHORNAME` 撰寫的其餘文章應該會出現在查詢窗格右側的結果窗格中。其看起來與下列類似： ``` { "data": { "allPostsByAuthor": { "posts": [ { "id": "8", "title": "A series of posts, Volume 8" }, { "id": "5", "title": "A series of posts, Volume 5" }, { "id": "3", "title": "A series of posts, Volume 3" }, { "id": "9", "title": "A series of posts, Volume 9" } ], "nextToken": null } } } ``` ## 使用集 到目前為止，`Post` 類型為統一金鑰/值物件。您也可以使用 AWS AppSyncDynamoDB 解析程式建立複雜物件的模型，例如集合、清單和映射。 讓我們將 `Post` 類型更新為包含標籤。文章可以有 0 個或多個標籤，這些標籤會以字串集的形式存放在 DynamoDB 中。您也會設定一些變動來新增和移除標籤，以及新查詢以掃描含特定標籤的文章。 + 選擇 **Schema (結構描述)** 標籤。 + 修改 **Schema (結構描述)** 窗格中的 `Post` 類型以新增 `tags` 欄位，如下所示： ``` type Post { id: ID! author: String title: String content: String url: String ups: Int! downs: Int! version: Int! tags: [String!] } ``` + 修改 **Schema (結構描述)** 窗格中的 `Query` 類型以新增 `allPostsByTag` 查詢，如下所示： ``` type Query { allPostsByTag(tag: String!, count: Int, nextToken: String): PaginatedPosts! allPostsByAuthor(author: String!, count: Int, nextToken: String): PaginatedPosts! allPost(count: Int, nextToken: String): PaginatedPosts! getPost(id: ID): Post } ``` + 修改 **Schema (結構描述)** 窗格中的 `Mutation` 類型以新增 `addTag` 和 `removeTag` 變動，如下所示： ``` type Mutation { addTag(id: ID!, tag: String!): Post removeTag(id: ID!, tag: String!): Post deletePost(id: ID!, expectedVersion: Int): Post upvotePost(id: ID!): Post downvotePost(id: ID!): Post updatePost( id: ID!, author: String, title: String, content: String, url: String, expectedVersion: Int! ): Post addPost( author: String!, title: String!, content: String!, url: String! ): Post! } ``` + 選擇**儲存**。 + 在右側的**資料類型**窗格中，尋找**查詢**類型上新建立的 **allPostsByTag** 欄位，然後選擇**連接**。 + 在 **Data source name (資料來源名稱)** 中，選擇 **PostDynamoDBTable**。 + 將以下內容貼到 **Configure the request mapping template (設定請求映射範本)** 區段： ``` { "version" : "2017-02-28", "operation" : "Scan", "filter": { "expression": "contains (tags, :tag)", "expressionValues": { ":tag": $util.dynamodb.toDynamoDBJson($context.arguments.tag) } } #if( ${context.arguments.count} ) ,"limit": $util.toJson($context.arguments.count) #end #if( ${context.arguments.nextToken} ) ,"nextToken": $util.toJson($context.arguments.nextToken) #end } ``` + 將以下內容貼到 **Configure the response mapping template (設定回應映射範本)** 區段： ``` { "posts": $utils.toJson($context.result.items) #if( ${context.result.nextToken} ) ,"nextToken": $util.toJson($context.result.nextToken) #end } ``` + 選擇**儲存**。 + 在右側的**資料類型**窗格中，尋找**變動**類型上新建立的 **addTag** 欄位，然後選擇**連接**。 + 在 **Data source name (資料來源名稱)** 中，選擇 **PostDynamoDBTable**。 + 將以下內容貼到 **Configure the request mapping template (設定請求映射範本)** 區段： ``` { "version" : "2017-02-28", "operation" : "UpdateItem", "key" : { "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id) }, "update" : { "expression" : "ADD tags :tags, version :plusOne", "expressionValues" : { ":tags" : { "SS": [ $util.toJson($context.arguments.tag) ] }, ":plusOne" : { "N" : 1 } } } } ``` + 將以下內容貼到 **Configure the response mapping template (設定回應映射範本)** 區段： ``` $utils.toJson($context.result) ``` + 選擇**儲存**。 + 在右側的**資料類型**窗格中，尋找**變動**類型上新建立的 **removeTag** 欄位，然後選擇**連接**。 + 在 **Data source name (資料來源名稱)** 中，選擇 **PostDynamoDBTable**。 + 將以下內容貼到 **Configure the request mapping template (設定請求映射範本)** 區段： ``` { "version" : "2017-02-28", "operation" : "UpdateItem", "key" : { "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id) }, "update" : { "expression" : "DELETE tags :tags ADD version :plusOne", "expressionValues" : { ":tags" : { "SS": [ $util.toJson($context.arguments.tag) ] }, ":plusOne" : { "N" : 1 } } } } ``` + 將以下內容貼到 **Configure the response mapping template (設定回應映射範本)** 區段： ``` $utils.toJson($context.result) ``` + 選擇**儲存**。 ### 呼叫 API 來使用標籤 現在您已設定解析程式， AWS AppSync 知道如何將傳入的 `removeTag`、 `addTag`和 `allPostsByTag`請求轉換為 DynamoDB`UpdateItem` 和 `Scan`操作。 為了嘗試看看，讓我們選擇您先前建立的其中一篇文章。例如，讓我們使用 `Nadia` 撰寫的一篇文章。 + 選擇 **Queries (查詢)** 標籤。 + 將以下查詢貼到 **Queries (查詢)** 窗格中： ``` query allPostsByAuthor { allPostsByAuthor( author: "Nadia" ) { posts { id title } nextToken } } ``` + 選擇 **Execute query (執行查詢)** (橘色播放按鈕)。 + Nadia 的所有文章應該會出現在查詢窗格右側的結果窗格中。其看起來與下列類似： ``` { "data": { "allPostsByAuthor": { "posts": [ { "id": "10", "title": "The cutest dog in the world" }, { "id": "11", "title": "Did you known...?" } ], "nextToken": null } } } ``` + 我們使用標題為 `"The cutest dog in the world"` 的文章。請記下其 `id`，因為您稍後將會用到它。 現在，讓我們嘗試新增 `dog` 標籤。 + 將以下變動貼到 **Queries (查詢)** 窗格。您也必須將 `id` 引數更新為您先前記下的值。 ``` mutation addTag { addTag(id:10 tag: "dog") { id title tags } } ``` + 選擇 **Execute query (執行查詢)** (橘色播放按鈕)。 + 使用新標籤更新的文章。 ``` { "data": { "addTag": { "id": "10", "title": "The cutest dog in the world", "tags": [ "dog" ] } } } ``` 您可以新增更多的標籤，如下所示： + 更新變動以將 `tag` 引數變更為 `puppy`。 ``` mutation addTag { addTag(id:10 tag: "puppy") { id title tags } } ``` + 選擇 **Execute query (執行查詢)** (橘色播放按鈕)。 + 使用新標籤更新的文章。 ``` { "data": { "addTag": { "id": "10", "title": "The cutest dog in the world", "tags": [ "dog", "puppy" ] } } } ``` 您也可以刪除標籤： + 將以下變動貼到 **Queries (查詢)** 窗格。您也必須將 `id` 引數更新為您先前記下的值。 ``` mutation removeTag { removeTag(id:10 tag: "puppy") { id title tags } } ``` + 選擇 **Execute query (執行查詢)** (橘色播放按鈕)。 + 貼文將會更新，且 `puppy` 標籤將會刪除。 ``` { "data": { "addTag": { "id": "10", "title": "The cutest dog in the world", "tags": [ "dog" ] } } } ``` 您也可以搜尋所有包含標籤的貼文： + 將以下查詢貼到 **Queries (查詢)** 窗格中： ``` query allPostsByTag { allPostsByTag(tag: "dog") { posts { id title tags } nextToken } } ``` + 選擇 **Execute query (執行查詢)** (橘色播放按鈕)。 + 具有 `dog` 標籤的所有文章將會傳回，如下所示： ``` { "data": { "allPostsByTag": { "posts": [ { "id": "10", "title": "The cutest dog in the world", "tags": [ "dog", "puppy" ] } ], "nextToken": null } } } ``` ## 使用清單和映射 除了使用 DynamoDB 集之外，您還可以使用 DynamoDB 清單和映射在單一物件中建立複雜資料的模型。 讓我們新增功能以將評論新增到文章。這將建模為 DynamoDB 中物件上的映射`Post`物件清單。 **注意：**在實際應用程式中，您會在它們自己的資料表中塑造評論。在本教學課程中，您將只是將它們新增至 `Post` 資料表。 + 選擇 **Schema (結構描述)** 標籤。 + 修改 **Schema (結構描述)** 窗格中新增 `Comment` 類型，如下所示： ``` type Comment { author: String! comment: String! } ``` + 修改 **Schema (結構描述)** 窗格中的 `Post` 類型以新增 `comments` 欄位，如下所示： ``` type Post { id: ID! author: String title: String content: String url: String ups: Int! downs: Int! version: Int! tags: [String!] comments: [Comment!] } ``` + 修改 **Schema (結構描述)** 窗格中的 `Mutation` 類型來新增 `addComment` 變動，如下所示： ``` type Mutation { addComment(id: ID!, author: String!, comment: String!): Post addTag(id: ID!, tag: String!): Post removeTag(id: ID!, tag: String!): Post deletePost(id: ID!, expectedVersion: Int): Post upvotePost(id: ID!): Post downvotePost(id: ID!): Post updatePost( id: ID!, author: String, title: String, content: String, url: String, expectedVersion: Int! ): Post addPost( author: String!, title: String!, content: String!, url: String! ): Post! } ``` + 選擇**儲存**。 + 在右側的**資料類型**窗格中，尋找**變動**類型上新建立的 **addComment** 欄位，然後選擇**連接**。 + 在 **Data source name (資料來源名稱)** 中，選擇 **PostDynamoDBTable**。 + 將以下內容貼到 **Configure the request mapping template (設定請求映射範本)** 區段： ``` { "version" : "2017-02-28", "operation" : "UpdateItem", "key" : { "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id) }, "update" : { "expression" : "SET comments = list_append(if_not_exists(comments, :emptyList), :newComment) ADD version :plusOne", "expressionValues" : { ":emptyList": { "L" : [] }, ":newComment" : { "L" : [ { "M": { "author": $util.dynamodb.toDynamoDBJson($context.arguments.author), "comment": $util.dynamodb.toDynamoDBJson($context.arguments.comment) } } ] }, ":plusOne" : $util.dynamodb.toDynamoDBJson(1) } } } ``` 這個更新表達式將會將包含新評論的清單附加到現有的 `comments` 清單。如果清單不存在，則會建立一個。 + 將以下內容貼到 **Configure the response mapping template (設定回應映射範本)** 區段： ``` $utils.toJson($context.result) ``` + 選擇**儲存**。 ### 呼叫 API 以新增評論 現在您已設定解析程式， AWS AppSync 知道如何將傳入`addComment`的請求轉換為 DynamoDB`UpdateItem` 操作。 讓我們透過將評論新增至您已新增標籤的相同文章，以嘗試此操作。 + 選擇 **Queries (查詢)** 標籤。 + 將以下查詢貼到 **Queries (查詢)** 窗格中： ``` mutation addComment { addComment( id:10 author: "Steve" comment: "Such a cute dog." ) { id comments { author comment } } } ``` + 選擇 **Execute query (執行查詢)** (橘色播放按鈕)。 + Nadia 的所有文章應該會出現在查詢窗格右側的結果窗格中。其看起來與下列類似： ``` { "data": { "addComment": { "id": "10", "comments": [ { "author": "Steve", "comment": "Such a cute dog." } ] } } } ``` 如果您多次執行要求，系統會將多個評論附加到清單。 ## 結論 在本教學課程中，您已建置 API，讓我們可以使用 AWS AppSync 和 GraphQL 在 DynamoDB 中操作 Post 物件。如需詳細資訊，請參閱[解析程式映射範本參考](resolver-mapping-template-reference.md#aws-appsync-resolver-mapping-template-reference)。 若要清除，您可以從主控台將 AppSync GraphQL API 刪除。 若要刪除您為此教學課程建立的 DynamoDB 資料表和 IAM 角色，您可以執行下列動作來刪除`AWSAppSyncTutorialForAmazonDynamoDB`堆疊，或造訪 CloudFormation 主控台並刪除堆疊： ``` aws cloudformation delete-stack \ --stack-name AWSAppSyncTutorialForAmazonDynamoDB ``` # 在 中使用 AWS Lambda 解析程式 AWS AppSync **注意** 我們現在主要支援 APPSYNC\$1JS 執行期及其文件。請考慮[在此處](https://docs.aws.amazon.com/appsync/latest/devguide/tutorials-js.html)使用 APPSYNC\$1JS 執行期及其指南。 您可以使用 AWS Lambda with AWS AppSync 來解析任何 GraphQL 欄位。例如，GraphQL 查詢可能會將呼叫傳送至 Amazon Relational Database Service (Amazon RDS) 執行個體，而 GraphQL 變動可能會寫入 Amazon Kinesis 串流。在本節中，我們將示範如何撰寫 Lambda 函數，根據 GraphQL 欄位操作的調用執行商業邏輯。 ## 建立 Lambda 函式 下列範例顯示寫入 的 Lambda 函數`Node.js`，該函數會在部落格文章應用程式中對部落格文章執行不同的操作。 ``` exports.handler = (event, context, callback) => { console.log("Received event {}", JSON.stringify(event, 3)); var posts = { "1": {"id": "1", "title": "First book", "author": "Author1", "url": "https://amazon.com/", "content": "SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1", "ups": "100", "downs": "10"}, "2": {"id": "2", "title": "Second book", "author": "Author2", "url": "https://amazon.com", "content": "SAMPLE TEXT AUTHOR 2 SAMPLE TEXT AUTHOR 2 SAMPLE TEXT", "ups": "100", "downs": "10"}, "3": {"id": "3", "title": "Third book", "author": "Author3", "url": null, "content": null, "ups": null, "downs": null }, "4": {"id": "4", "title": "Fourth book", "author": "Author4", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4", "ups": "1000", "downs": "0"}, "5": {"id": "5", "title": "Fifth book", "author": "Author5", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT", "ups": "50", "downs": "0"} }; var relatedPosts = { "1": [posts['4']], "2": [posts['3'], posts['5']], "3": [posts['2'], posts['1']], "4": [posts['2'], posts['1']], "5": [] }; console.log("Got an Invoke Request."); switch(event.field) { case "getPost": var id = event.arguments.id; callback(null, posts[id]); break; case "allPosts": var values = []; for(var d in posts){ values.push(posts[d]); } callback(null, values); break; case "addPost": // return the arguments back callback(null, event.arguments); break; case "addPostErrorWithData": var id = event.arguments.id; var result = posts[id]; // attached additional error information to the post result.errorMessage = 'Error with the mutation, data has changed'; result.errorType = 'MUTATION_ERROR'; callback(null, result); break; case "relatedPosts": var id = event.source.id; callback(null, relatedPosts[id]); break; default: callback("Unknown field, unable to resolve" + event.field, null); break; } }; ``` 此 Lambda 函數會依 ID 擷取文章、新增文章、擷取文章清單，以及擷取特定文章的相關文章。 **注意：**Lambda 函數使用 上的 `switch`陳述式`event.field`來判斷目前正在解析哪個欄位。 使用 AWS 管理主控台或 AWS CloudFormation 堆疊建立此 Lambda 函數。若要從 CloudFormation 堆疊建立函數，您可以使用下列 AWS Command Line Interface (AWS CLI) 命令： ``` aws cloudformation create-stack --stack-name AppSyncLambdaExample \ --template-url https://s3.us-west-2.amazonaws.com/awsappsync/resources/lambda/LambdaCFTemplate.yaml \ --capabilities CAPABILITY_NAMED_IAM ``` 您也可以從這裡在美國西部 （奧勒岡） AWS 區域中啟動 AWS CloudFormation 堆疊： [https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/lambda/LambdaCFTemplate.yaml](https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/lambda/LambdaCFTemplate.yaml) ## 設定 Lambda 的資料來源 建立 Lambda 函數後，在 AWS AppSync 主控台中導覽至 GraphQL API，然後選擇**資料來源**索引標籤。 選擇**建立資料來源**，輸入易記**的資料來源名稱** （例如 **Lambda**)，然後針對**資料來源類型**選擇 **AWS Lambda 函數**。針對**區域**，選擇與函數相同的區域。（如果您從提供的 CloudFormation 堆疊建立函數，則函數可能位於 **US-WEST-2**。) 針對**函數 ARN**，選擇 Lambda 函數的 Amazon Resource Name (ARN)。 選擇 Lambda 函數後，您可以建立新的 AWS Identity and Access Management (IAM) 角色 ( AWS AppSync 會為其指派適當的許可），或選擇具有下列內嵌政策的現有角色： ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "lambda:InvokeFunction" ], "Resource": "arn:aws:lambda:us-east-1:111122223333:function:LAMBDA_FUNCTION" } ] } ``` ------ 您還必須為 IAM 角色設定與 AWS AppSync 的信任關係，如下所示： ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "appsync.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` ------ ## 建立 GraphQL 結構描述 現在資料來源已連接至 Lambda 函數，請建立 GraphQL 結構描述。 從 AWS AppSync 主控台的結構描述編輯器，請確定您的結構描述符合下列結構描述： ``` schema { query: Query mutation: Mutation } type Query { getPost(id:ID!): Post allPosts: [Post] } type Mutation { addPost(id: ID!, author: String!, title: String, content: String, url: String): Post! } type Post { id: ID! author: String! title: String content: String url: String ups: Int downs: Int relatedPosts: [Post] } ``` ## 設定解析程式 現在您已註冊 Lambda 資料來源和有效的 GraphQL 結構描述，您可以使用解析程式將 GraphQL 欄位連線至 Lambda 資料來源。 若要建立解析程式，您需要映射範本。若要進一步了解映射範本，請參閱 [Resolver Mapping Template Overview](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview)。 如需 Lambda 映射範本的詳細資訊，請參閱 [Resolver mapping template reference for Lambda](resolver-mapping-template-reference-lambda.md#aws-appsync-resolver-mapping-template-reference-lambda)。 在此步驟中，您將解析程式連接至下列欄位的 Lambda 函數：`getPost(id:ID!): Post`、`addPost(id: ID!, author: String!, title: String, content: String, url: String): Post!`、 `allPosts: [Post]`和 `Post.relatedPosts: [Post]`。 從 AWS AppSync 主控台的結構描述編輯器的右側，選擇**連接解析程式**`getPost(id:ID!): Post`。 然後，在**動作功能表中**，選擇**更新執行時間**，然後選擇**單位解析程式 （僅限 VTL)**。 之後，選擇您的 Lambda 資料來源。在 **request mapping template (請求映射範本)** 區段中，選擇 **Invoke And Forward Arguments (叫用並轉發引數)**。 修改 `payload` 物件以新增欄位名稱。您的範本看起來應該如下所示： ``` { "version": "2017-02-28", "operation": "Invoke", "payload": { "field": "getPost", "arguments": $utils.toJson($context.arguments) } } ``` 在 **response mapping template (回應映射範本)** 區段中，選擇 **Return Lambda Result (傳回 Lambda 結果)**。 在此案例中，使用原本的基礎範本。它看起來應該如下所示： ``` $utils.toJson($context.result) ``` 選擇**儲存**。您已成功連接第一個解析程式。對剩餘欄位重複此操作，如下所示： `addPost(id: ID!, author: String!, title: String, content: String, url: String): Post!` 請求映射範本： ``` { "version": "2017-02-28", "operation": "Invoke", "payload": { "field": "addPost", "arguments": $utils.toJson($context.arguments) } } ``` `addPost(id: ID!, author: String!, title: String, content: String, url: String): Post!` 回應映射範本： ``` $utils.toJson($context.result) ``` `allPosts: [Post]` 請求映射範本： ``` { "version": "2017-02-28", "operation": "Invoke", "payload": { "field": "allPosts" } } ``` `allPosts: [Post]` 回應映射範本： ``` $utils.toJson($context.result) ``` `Post.relatedPosts: [Post]` 請求映射範本： ``` { "version": "2017-02-28", "operation": "Invoke", "payload": { "field": "relatedPosts", "source": $utils.toJson($context.source) } } ``` `Post.relatedPosts: [Post]` 回應映射範本： ``` $utils.toJson($context.result) ``` ## 測試 GraphQL API 現在，您的 Lambda 函式已經連接到 GraphQL 解析程式，您可以使用主控台或用戶端應用程式執行一些變動和查詢。 在 AWS AppSync 主控台的左側，選擇**查詢**，然後貼上下列程式碼： ### addPost Mutation ``` mutation addPost { addPost( id: 6 author: "Author6" title: "Sixth book" url: "https://www.amazon.com/" content: "This is the book is a tutorial for using GraphQL with AWS AppSync." ) { id author title content url ups downs } } ``` ### getPost Query ``` query getPost { getPost(id: "2") { id author title content url ups downs } } ``` ### allPosts Query ``` query allPosts { allPosts { id author title content url ups downs relatedPosts { id title } } } ``` ## 傳回錯誤 任何指定的欄位解析度都可能導致錯誤。透過 AWS AppSync，您可以從下列來源引發錯誤： + 請求或回應映射範本 + Lambda 函式 ### 從映射範本 若要引發刻意錯誤，您可以使用 Velocity 範本語言 (VTL) 範本中的`$utils.error`協助程式方法。它使用 `errorMessage`、`errorType`，及選用的 `data` 值做為引數。發生錯誤時，`data` 可將額外的資料傳回給用戶端。`data` 物件會新增到 GraphQL 最後回應中的 `errors`。 以下範例說明如何在 `Post.relatedPosts: [Post]` 回應映射範本中使用它： ``` $utils.error("Failed to fetch relatedPosts", "LambdaFailure", $context.result) ``` 這會產生類似下列的 GraphQL 回應： ``` { "data": { "allPosts": [ { "id": "2", "title": "Second book", "relatedPosts": null }, ... ] }, "errors": [ { "path": [ "allPosts", 0, "relatedPosts" ], "errorType": "LambdaFailure", "locations": [ { "line": 5, "column": 5 } ], "message": "Failed to fetch relatedPosts", "data": [ { "id": "2", "title": "Second book" }, { "id": "1", "title": "First book" } ] } ] } ``` 其中的 `allPosts[0].relatedPosts` 為 *null*，因為錯誤以及 `errorMessage`、`errorType` 和 `data` 出現在 `data.errors[0]` 物件中。 ### 從 Lambda 函式 AWS AppSync 也了解 Lambda 函數擲回的錯誤。Lambda 程式設計模型可讓您引發*已處理的*錯誤。如果 Lambda 函數擲回錯誤， AWS AppSync 無法解析目前的欄位。回應中只會設定從 Lambda 傳回的錯誤訊息。目前，您無法透過從 Lambda 函數引發錯誤，將任何無關的資料傳遞回用戶端。 **注意**：如果您的 Lambda 函數引發*未處理的*錯誤， AWS AppSync 會使用 Lambda 設定的錯誤訊息。 下列 Lambda 函式會引發錯誤： ``` exports.handler = (event, context, callback) => { console.log("Received event {}", JSON.stringify(event, 3)); callback("I fail. Always."); }; ``` 這會傳回類似下列的 GraphQL 回應： ``` { "data": { "allPosts": [ { "id": "2", "title": "Second book", "relatedPosts": null }, ... ] }, "errors": [ { "path": [ "allPosts", 0, "relatedPosts" ], "errorType": "Lambda:Handled", "locations": [ { "line": 5, "column": 5 } ], "message": "I fail. Always." } ] } ``` ## 進階使用案例：批次處理 此範例中的 Lambda 函數有一個`relatedPosts`欄位，可傳回指定文章的相關文章清單。在範例查詢中，來自 Lambda 函數`allPosts`的欄位調用會傳回五個文章。因為我們指定了也要`relatedPosts`解析每個傳回的文章，所以會叫用 `relatedPosts` 欄位操作五次。 ``` query allPosts { allPosts { // 1 Lambda invocation - yields 5 Posts id author title content url ups downs relatedPosts { // 5 Lambda invocations - each yields 5 posts id title } } } ``` 雖然這在此特定範例中可能聽起來並不重要，但這種複合式過度擷取可能會快速破壞應用程式。 如果您要在同一查詢中，再次擷取傳回之相關 `Posts` 的 `relatedPosts`，那麼叫用的次數將大幅增加。 ``` query allPosts { allPosts { // 1 Lambda invocation - yields 5 Posts id author title content url ups downs relatedPosts { // 5 Lambda invocations - each yield 5 posts = 5 x 5 Posts id title relatedPosts { // 5 x 5 Lambda invocations - each yield 5 posts = 25 x 5 Posts id title author } } } } ``` 在此相對簡單的查詢中， AWS AppSync 會叫用 Lambda 函數 1 \$1 5 \$1 25 = 31 次。 這是一個相當常見的挑戰，通常稱為 N\$11 問題 (在此例中，N = 5)，它可能會增加應用程式的延遲和成本。 解決此問題的方法之一，是將類似的欄位解析程式請求一起批次處理。在此範例中，它可以改為解析指定批次文章的相關文章清單，而不是讓 Lambda 函數解析單一指定文章的相關文章清單。 為了示範，讓我們將 `Post.relatedPosts: [Post]` 解析程式切換為啟用批次的解析程式。 在 AWS AppSync 主控台的右側，選擇現有的`Post.relatedPosts: [Post]`解析程式。將請求映射範本變更為以下內容： ``` { "version": "2017-02-28", "operation": "BatchInvoke", "payload": { "field": "relatedPosts", "source": $utils.toJson($context.source) } } ``` 只有 `operation` 欄位從 `Invoke` 變更為 `BatchInvoke`。承載欄位現在會成為範本中指定之任何項目的陣列。在此範例中，Lambda 函數會收到下列項目做為輸入： ``` [ { "field": "relatedPosts", "source": { "id": 1 } }, { "field": "relatedPosts", "source": { "id": 2 } }, ... ] ``` 在請求映射範本中指定 `BatchInvoke` 時，Lambda 函數會收到請求清單，並傳回結果清單。 具體而言，結果清單必須符合請求承載項目的大小和順序，以便 AWS AppSync 可以相應地符合結果。 在此批次範例中，Lambda 函數會傳回一批結果，如下所示： ``` [ [{"id":"2","title":"Second book"}, {"id":"3","title":"Third book"}], // relatedPosts for id=1 [{"id":"3","title":"Third book"}] // relatedPosts for id=2 ] ``` Node.js 中的下列 Lambda 函數示範 `Post.relatedPosts` 欄位的此批次處理功能，如下所示： ``` exports.handler = (event, context, callback) => { console.log("Received event {}", JSON.stringify(event, 3)); var posts = { "1": {"id": "1", "title": "First book", "author": "Author1", "url": "https://amazon.com/", "content": "SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1", "ups": "100", "downs": "10"}, "2": {"id": "2", "title": "Second book", "author": "Author2", "url": "https://amazon.com", "content": "SAMPLE TEXT AUTHOR 2 SAMPLE TEXT AUTHOR 2 SAMPLE TEXT", "ups": "100", "downs": "10"}, "3": {"id": "3", "title": "Third book", "author": "Author3", "url": null, "content": null, "ups": null, "downs": null }, "4": {"id": "4", "title": "Fourth book", "author": "Author4", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4", "ups": "1000", "downs": "0"}, "5": {"id": "5", "title": "Fifth book", "author": "Author5", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT", "ups": "50", "downs": "0"} }; var relatedPosts = { "1": [posts['4']], "2": [posts['3'], posts['5']], "3": [posts['2'], posts['1']], "4": [posts['2'], posts['1']], "5": [] }; console.log("Got a BatchInvoke Request. The payload has %d items to resolve.", event.length); // event is now an array var field = event[0].field; switch(field) { case "relatedPosts": var results = []; // the response MUST contain the same number // of entries as the payload array for (var i=0; i< event.length; i++) { console.log("post {}", JSON.stringify(event[i].source)); results.push(relatedPosts[event[i].source.id]); } console.log("results {}", JSON.stringify(results)); callback(null, results); break; default: callback("Unknown field, unable to resolve" + field, null); break; } }; ``` ### 傳回個別錯誤 上述範例顯示，您可以從 Lambda 函數傳回單一錯誤，或從映射範本引發錯誤。對於批次叫用，從 Lambda 函數引發錯誤會將整個批次標記為失敗。對於發生無法復原錯誤的特定案例，例如與資料存放區的連線失敗，這可能是可接受的。不過，如果批次中的某些項目成功，而其他項目失敗，則有可能同時傳回錯誤和有效資料。Because AWS AppSync 需要批次回應來列出符合批次原始大小的元素，您必須定義可以區分有效資料與錯誤的資料結構。 例如，如果 Lambda 函數預期會傳回一批相關文章，您可以選擇傳回`Response`物件清單，其中每個物件都有選用*的資料*、*errorMessage* 和 *errorType* 欄位。如果出現 *errorMessage* 欄位，表示發生錯誤。 下列程式碼顯示如何更新 Lambda 函數： ``` exports.handler = (event, context, callback) => { console.log("Received event {}", JSON.stringify(event, 3)); var posts = { "1": {"id": "1", "title": "First book", "author": "Author1", "url": "https://amazon.com/", "content": "SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1", "ups": "100", "downs": "10"}, "2": {"id": "2", "title": "Second book", "author": "Author2", "url": "https://amazon.com", "content": "SAMPLE TEXT AUTHOR 2 SAMPLE TEXT AUTHOR 2 SAMPLE TEXT", "ups": "100", "downs": "10"}, "3": {"id": "3", "title": "Third book", "author": "Author3", "url": null, "content": null, "ups": null, "downs": null }, "4": {"id": "4", "title": "Fourth book", "author": "Author4", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4", "ups": "1000", "downs": "0"}, "5": {"id": "5", "title": "Fifth book", "author": "Author5", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT", "ups": "50", "downs": "0"} }; var relatedPosts = { "1": [posts['4']], "2": [posts['3'], posts['5']], "3": [posts['2'], posts['1']], "4": [posts['2'], posts['1']], "5": [] }; console.log("Got a BatchInvoke Request. The payload has %d items to resolve.", event.length); // event is now an array var field = event[0].field; switch(field) { case "relatedPosts": var results = []; results.push({ 'data': relatedPosts['1'] }); results.push({ 'data': relatedPosts['2'] }); results.push({ 'data': null, 'errorMessage': 'Error Happened', 'errorType': 'ERROR' }); results.push(null); results.push({ 'data': relatedPosts['3'], 'errorMessage': 'Error Happened with last result', 'errorType': 'ERROR' }); callback(null, results); break; default: callback("Unknown field, unable to resolve" + field, null); break; } }; ``` 在此範例中，下列回應映射範本會剖析 Lambda 函數的每個項目，並引發任何發生的錯誤： ``` #if( $context.result && $context.result.errorMessage ) $utils.error($context.result.errorMessage, $context.result.errorType, $context.result.data) #else $utils.toJson($context.result.data) #end ``` 此範例會傳回類似下列的 GraphQL 回應： ``` { "data": { "allPosts": [ { "id": "1", "relatedPostsPartialErrors": [ { "id": "4", "title": "Fourth book" } ] }, { "id": "2", "relatedPostsPartialErrors": [ { "id": "3", "title": "Third book" }, { "id": "5", "title": "Fifth book" } ] }, { "id": "3", "relatedPostsPartialErrors": null }, { "id": "4", "relatedPostsPartialErrors": null }, { "id": "5", "relatedPostsPartialErrors": null } ] }, "errors": [ { "path": [ "allPosts", 2, "relatedPostsPartialErrors" ], "errorType": "ERROR", "locations": [ { "line": 4, "column": 9 } ], "message": "Error Happened" }, { "path": [ "allPosts", 4, "relatedPostsPartialErrors" ], "data": [ { "id": "2", "title": "Second book" }, { "id": "1", "title": "First book" } ], "errorType": "ERROR", "locations": [ { "line": 4, "column": 9 } ], "message": "Error Happened with last result" } ] } ``` ### 設定批次大小上限 根據預設，使用 時`BatchInvoke`， AWS AppSync 會以最多五個項目的批次傳送請求到您的 Lambda 函數。您可以設定 Lambda 解析程式的批次大小上限。 若要在解析程式上設定批次大小上限，請在 AWS Command Line Interface () 中使用下列命令AWS CLI： ``` $ aws appsync create-resolver --api-id --type-name Query --field-name relatedPosts \ --request-mapping-template "