翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# リゾルバーと関数のAWS AppSync JavaScript ランタイム機能
`APPSYNC_JS` ランタイム環境には [ECMAScript (](https://262.ecma-international.org/6.0/)ES) バージョン 6.0 と同様の機能が備わっています。一部の機能をサポートし、ES 仕様に含まれない追加のメソッド (ユーティリティ) も提供しています。次のトピックでは、サポートされるすべての言語機能の一覧を示します。
+ [サポートされているランタイム機能](https://docs.aws.amazon.com/appsync/latest/devguide/supported-features.html) - サポートされているコア機能、プリミティブオブジェクト、組み込みオブジェクトと関数などの詳細について説明します。
+ [組み込みユーティリティ](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html) - 変数には、データの操作を容易にする一般的なユーティリティメソッドが含まれています。特に指定されていない限り、すべてのユーティリティでは UTF-8 文字セットが使用されます。
+ [組み込みモジュール](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-modules-js.html) - 組み込みモジュールが JavaScript リゾルバーと関数の記述にどのように役立つかについて説明します。
+ [ランタイムユーティリティ](https://docs.aws.amazon.com/appsync/latest/devguide/runtime-utils-js.html) - ランタイムライブラリには、リゾルバーと関数のランタイムプロパティを制御または変更するためのユーティリティが用意されています。
+ [util.time のタイムヘルパー](https://docs.aws.amazon.com/appsync/latest/devguide/time-helpers-in-util-time-js.html) - util.time 変数には、タイムスタンプの生成、日時形式間の変換、および日時文字列の解析に役立つ日時メソッドが含まれています。日時形式の構文は DateTimeFormatter に基づいています。詳細については、[DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html) を参照してください。
+ [util.dynamodb のDynamoDB ヘルパー](https://docs.aws.amazon.com/appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html) - util.dynamodb には、Amazon DynamoDB に対するデータの読み書きを容易にするヘルパーメソッド (自動型マッピングやフォーマットなど) が含まれています。
+ [util.http の HTTP ヘルパー](https://docs.aws.amazon.com/appsync/latest/devguide/http-helpers-in-utils-http-js.html) - util.http ユーティリティには、HTTP リクエストパラメータの管理やレスポンスヘッダーの追加に使用できるヘルパーメソッドが用意されています。
+ [util.transform の変換ヘルパー](https://docs.aws.amazon.com/appsync/latest/devguide/transformation-helpers-in-utils-transform-js.html) - util.transform には、データソースに対して複雑な操作を簡単に実行できるヘルパーメソッドが含まれています。
+ [util.str の文字列ヘルパー](https://docs.aws.amazon.com/appsync/latest/devguide/str-helpers-in-util-str-js.html) - util.str には、一般的な文字列オペレーションに役立つメソッドが含まれています。
+ [拡張機能](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html) - 拡張機能には、リゾルバー内で追加のアクションを行うためのメソッドのセットが含まれています。
+ [util.xml の XML ヘルパー](https://docs.aws.amazon.com/appsync/latest/devguide/xml-helpers-in-util-xml-js.html) - util.xml には、XML 文字列変換に役立つメソッドが含まれています。
**注記**
現在、このリファレンスはランタイムバージョン **1.0.0** にのみ適用されます。
# サポートされているランタイム機能
以下のセクションでは、APPSYNC\$1JS ランタイムでサポートされる機能セットについて説明します。
## 主要機能
次の主要機能がサポートされています。
------
#### [ Types ]
次のタイプの BGP がサポートされています。
+ 数字
+ 文字列
+ ブール値
+ objects
+ 配列
+ 関数
------
#### [ Operators ]
次のような演算子がサポートされています。
+ 標準の数学演算子 (`+`、`-`、`/`、`%`、`*` など)
+ Null 合体演算子 (`??`)
+ オプションのチェーニング (`?.`)
+ ビット演算子
+ `void` および `typeof` 演算子
+ スプレッド演算子 (`...`)
以下は、サポートされていない演算子です。
+ 単項演算子 (`++`、`--`、および `~`)
+ `in` operator
**注記**
`Object.hasOwn` 演算子を使用して、指定したプロパティが指定されたオブジェクト内にあるかどうかを調べます。
------
#### [ Statements ]
次のステートメントがサポートされています。
+ `const`
+ `let`
+ `var`
+ `break`
+ `else`
+ `for-in`
+ `for-of`
+ `if`
+ `return`
+ `switch`
+ スプレッド構文
ただし、以下はサポートしていません。
+ `catch`
+ `continue`
+ `do-while`
+ `finally`
+ `for(initialization; condition; afterthought)`
**注記**
ただし、サポートされている `for-in` および `for-of` 式は例外です。
+ `throw`
+ `try`
+ `while`
+ ラベル付きステートメント
------
#### [ Literals ]
以下の ES 6 [テンプレートリテラル](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals)がサポートされています。
+ 複数行文字列
+ 式の補間
+ ネストテンプレート
------
#### [ Functions ]
以下の構文がサポートされています。
+ 関数宣言はサポートされています。
+ ES 6 アロー関数はサポートされています。
+ ES 6 REST パラメータ構文はサポートされています。
------
#### [ Strict mode ]
関数は Strict モードで動作するため、関数コードに `use_strict` ステートメントを追加する必要はありません。これは変更できません。
------
## プリミティブオブジェクト
以下の ES プリミティブオブジェクトがサポートされています。
------
#### [ Object ]
以下のオブジェクトがサポートされています。
+ `Object.assign()`
+ `Object.entries()`
+ `Object.hasOwn()`
+ `Object.keys()`
+ `Object.values()`
+ `delete`
------
#### [ String ]
以下の文字列がサポートされています。
+ `String.prototype.length()`
+ `String.prototype.charAt()`
+ `String.prototype.concat()`
+ `String.prototype.endsWith()`
+ `String.prototype.indexOf()`
+ `String.prototype.lastIndexOf()`
+ `String.raw()`
+ `String.prototype.replace()`
**注記**
正規表現はサポートされていません。
ただし、Java スタイルの正規表現コンストラクトは、指定されたパラメータでサポートされています。詳細については、「[パターン](https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)」を参照してください。
+ `String.prototype.replaceAll()`
**注記**
正規表現はサポートされていません。
ただし、Java スタイルの正規表現コンストラクトは、指定されたパラメータでサポートされています。詳細については、「[パターン](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 ]
次の番号がサポートされています。
+ `Number.isFinite`
+ `Number.isNaN`
------
## 組み込みオブジェクトと関数
以下の ES 5.1 グローバル関数がサポートされています。
------
#### [ Math ]
次の Math 関数はサポートされていません。
+ `Math.random()`
+ `Math.min()`
+ `Math.max()`
+ `Math.round()`
+ `Math.floor()`
+ `Math.ceil()`
------
#### [ Array ]
以下の配列メソッドがサポートされています。
+ `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()`
**注記**
`Array.prototype.sort()` は引数はサポートしていません。
+ `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 ]
コンソールオブジェクトはデバッグに使用できます。ライブクエリの実行中、コンソールのログ/エラーステートメントが Amazon CloudWatch Logs に送信されます (ロギングが有効になっている場合)。`evaluateCode` でのコード評価中、コマンドレスポンスにログステートメントが返されます。
+ `console.error()`
+ `console.log()`
------
#### [ Function ]
+ `apply`、`bind` `call` メソッドはサポートされていません。
+ 関数コンストラクタはサポートされていません。
+ 関数を引数として渡すことはサポートされていません。
+ 再帰的な関数呼び出しはサポートされていません。
------
#### [ JSON ]
以下の JSON メソッドがサポートされています。
+ `JSON.parse()`
**注記**
解析された文字列が有効な JSON でない場合は、空白の文字列を返します。
+ `JSON.stringify()`
------
#### [ Promises ]
非同期プロセスはサポートされておらず、Promise もサポートされていません。
**注記**
ネットワークおよびファイルシステムへのアクセスは、 `APPSYNC_JS`ランタイム内ではサポートされていません AWS AppSync。 は、 AWS AppSync リゾルバーまたは AWS AppSync 関数によって行われたリクエストに基づいて、すべての I/O オペレーション AWS AppSync を処理します。
------
## Globals
以下のグローバル定数がサポートされています。
+ `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`
## エラータイプ
`throw` でエラーをスローすることはサポートされていません。`util.error()` 関数を使用するとエラーを返すことができます。`util.appendError` 関数を使用して GraphQL レスポンスにエラーを含めることができます。
詳細については、「[エラー utils](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html#utility-helpers-in-error-js)」を参照してください。
# 組み込みユーティリティ
`util` 変数には、データの操作を容易にする一般的なユーティリティメソッドが含まれています。特に指定されていない限り、すべてのユーティリティでは UTF-8 文字セットが使用されます。
## エンコーディング utils
### エンコーディング utils リスト
**`util.urlEncode(String)`**
入力文字列を `application/x-www-form-urlencoded` でエンコードされた文字列として返します。
**`util.urlDecode(String)`**
`application/x-www-form-urlencoded` でエンコードされた文字列をデコードして、エンコードされていない形式に戻します。
**`util.base64Encode(string) : string`**
入力を base64 でエンコードされた文字列にエンコードします。
**`util.base64Decode(string) : string`**
base64 エンコードされた文字列からデータをデコードします。
## ID 生成 utils
### ID 生成 utils リスト
**`util.autoId()`**
ランダムに生成された 128 ビットの UUID を返します。
**`util.autoUlid()`**
ランダムに生成された 128 ビットの ULID (辞書的にソート可能なユニバーサルユニーク識別子) を返します。
**`util.autoKsuid()`**
長さ 27 の文字列としてエンコードされた、ランダムに生成された 128 ビットの KSUID (K ソート可能な固有識別子) base62 を返します。
## エラー utils
### エラー utils リスト
**`util.error(String, String?, Object?, Object?)`**
カスタムエラーをスローします。これは、テンプレートがリクエストまたは呼び出し結果でエラーを検出した場合に、リクエストまたはレスポンスのマッピングテンプレートで使用できます。また、`errorType` フィールド、`data` フィールド、および `errorInfo` フィールドを指定できます。`data` の値は、GraphQL レスポンスの `errors` 内の該当する `error` ブロックに追加されます。
`data` はクエリ選択セットに基づいてフィルタリングされます。`errorInfo` の値は、GraphQL レスポンスの `errors` 内の該当する `error` ブロックに追加されます。
`errorInfo` はクエリ選択セットに基づいてフィルタリング**されません**。
**`util.appendError(String, String?, Object?, Object?)`**
カスタムエラーを追加します。これは、テンプレートがリクエストまたは呼び出し結果でエラーを検出した場合に、リクエストまたはレスポンスのマッピングテンプレートで使用できます。また、`errorType` フィールド、`data` フィールド、および `errorInfo` フィールドを指定できます。`util.error(String, String?, Object?, Object?)` とは異なり、テンプレートの評価は中断されないため、データを呼び出し元に返すことができます。`data` の値は、GraphQL レスポンスの `errors` 内の該当する `error` ブロックに追加されます。
`data` はクエリ選択セットに基づいてフィルタリングされます。`errorInfo` の値は、GraphQL レスポンスの `errors` 内の該当する `error` ブロックに追加されます。
`errorInfo` はクエリ選択セットに基づいてフィルタリング**されません**。
## タイプとパターンマッチングの utils
### タイプとパターンマッチングの utils リスト
**`util.matches(String, String) : Boolean`**
最初の引数で指定されたパターンが、2 番目の引数で指定されたデータと一致する場合は true を返します。パターンは正規表現である必要があります (例: `util.matches("a*b", "aaaaab")`)。この機能は Java の Pattern に基づいています。詳細については、[Pattern](https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html) を参照してください。
**`util.authType()`**
リクエストで使用されているマルチ認可タイプを表す文字列型 (String) の値を返します。「IAM 認可」、「ユーザープールの認可」、「オープン ID Connect 認可」、または「API キー認可」のいずれかを返します。
## 戻り値動作 utils
### 戻り値動作 utils リスト
**`util.escapeJavaScript(String)`**
入力文字列を JavasScript のエスケープした文字列として返します。
## リゾルバー認可 utils
### リゾルバー認可 utils リスト
**`util.unauthorized()`**
解決されるフィールドに対して `Unauthorized` をスローします。リクエストまたはレスポンスのマッピングテンプレートでこれを使用し、呼び出し元にそのフィールドの解決が許可されるかどうかを判別します。
# ビルトインモジュール
モジュールは `APPSYNC_JS` ランタイムの一部であり、JavaScript リゾルバーと関数の作成に役立つユーティリティを提供します。サンプルと例については、[aws-appsync-resolver-samples](https://github.com/aws-samples/aws-appsync-resolver-samples) GitHub リポジトリを参照してください。
## DynamoDB モジュール関数
DynamoDB モジュール関数を使用すると、DynamoDB データソースを操作する際のエクスペリエンスが向上します。タイプマッピングを追加しなくても、関数を使用して DynamoDB データソースに対してリクエストを行うことができます。
モジュールは `@aws-appsync/utils/dynamodb` を使用してインポートされます。
```
// Modules are imported using @aws-appsync/utils/dynamodb
import * as ddb from '@aws-appsync/utils/dynamodb';
```
### 関数
#### 関数のリスト
**` get(payload: GetInput): DynamoDBGetItemRequest`**
GetInput については、「[入力](#built-in-ddb-modules-inputs)」を参照してください。
DynamoDB に [GetItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-getitem) リクエストを行うための `DynamoDBGetItemRequest` オブジェクトを生成します。
```
import { get } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
return get({ key: { id: ctx.args.id } });
}
```
**`put(payload): DynamoDBPutItemRequest`**
DynamoDB に [PutItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem) リクエストを行うための `DynamoDBPutItemRequest` オブジェクトを生成します。
```
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`**
DynamoDB に [DeleteItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-deleteitem) リクエストを行うための `DynamoDBDeleteItemRequest` オブジェクトを生成します。
```
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
return ddb.remove({ key: { id: ctx.args.id } });
}
```
**`scan(payload): DynamoDBScanRequest`**
DynamoDB に [Scan](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan) リクエストを行うための`DynamoDBScanRequest`を生成します。
```
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`**
[Sync](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-sync) リクエストを行う `DynamoDBSyncRequest` オブジェクトを生成します。リクエストは、前回のクエリ (デルタ更新) 以降に変更されたデータのみを受け取ります。リクエストは、バージョン管理された DynamoDB データソースに対してのみ行うことができます。
```
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`**
DynamoDB に [UpdateItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-updateitem) リクエストを行うための `DynamoDBUpdateItemRequest` オブジェクトを生成します。
### オペレーション
オペレーションヘルパーを使用すると、更新中にデータの一部に対して特定のアクションを実行できます。はじめに、`@aws-appsync/utils/dynamodb` から `operations` をインポートしてください。
```
// Modules are imported using operations
import {operations} from '@aws-appsync/utils/dynamodb';
```
#### オペレーションリスト
**`add(payload)`**
DynamoDB を更新するときに新しい属性項目を追加するヘルパー関数。
**例**
ID 値を使用して既存の DynamoDB 項目に住所 (番地、市区町村、郵便番号) を追加するには
```
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)`**
DynamoDB の既存のリストにペイロードを追加するヘルパー関数。
**例**
更新中に新しく追加されたフレンド ID (`newFriendIds`) を既存のフレンドリスト (`friendsIds`) に追加するには
```
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?)`**
DynamoDB を更新するときに項目内の既存の属性値をデクリメントするヘルパー関数。
**例**
フレンドカウンター (`friendsCount`) を 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?)`**
DynamoDB を更新するときに項目内の既存の属性値をインクリメントするヘルパー関数。
**例**
フレンドカウンター (`friendsCount`) を 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)`**
DynamoDB の既存のリストの前に追加するヘルパー関数。
**例**
更新時に、新しく追加されたフレンド ID (`newFriendIds`) を既存のフレンドリスト (`friendsIds`) の先頭に追加するには
```
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)`**
DynamoDB の項目を更新するときに既存の属性を置き換えるヘルパー関数。これは、ペイロードのキーだけでなく、属性のオブジェクトまたはサブオブジェクト全体を更新したい場合に便利です。
**例**
`info` オブジェクト内の住所 (番地、市区町村、郵便番号) を置き換えるには
```
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)`**
リスト内の項目を置き換えるヘルパー関数。
**例**
更新 (`newFriendIds`) のスコープで、この例では `friendsIds` を使用してリスト (`updateListItem`) の 2 番目の項目 (index: `1`、new ID:`102`) と 3 番目の項目 (index: `2`、new ID:`112`) の ID 値を更新しました。
```
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 });
}
```
### 入力
#### 入力リスト
**`Type GetInput`**
```
GetInput: {
consistentRead?: boolean;
key: DynamoDBKey;
}
```
**タイプ宣言**
+ `consistentRead?: boolean` (オプション)
DynamoDB で強力な整合性のある読み込みを実行するかどうかを指定するオプションのブール値。
+ `key: DynamoDBKey` (必須)
DynamoDB の項目のキーを指定する必須パラメータ。DynamoDB の項目には、単一のハッシュキーとソートキーが含まれています。
**`Type PutInput`**
```
PutInput: {
_version?: number;
condition?: DynamoDBFilterObject | null;
customPartitionKey?: string;
item: Partial;
key: DynamoDBKey;
populateIndexFields?: boolean;
}
```
**タイプ宣言**
+ `_version?: number` (オプション)
+ `condition?: DynamoDBFilterObject | null` (オプション)
DynamoDB テーブルにオブジェクトを格納する際、オプションで条件式を指定することができます。この条件式は、操作を実行する前にすでに DynamoDB に格納されているオブジェクトの状態に基づいて、リクエストを成功させるかどうかを制御します。
+ `customPartitionKey?: string` (オプション)
有効にすると、この文字列値によって、バージョニングが有効になっているときにデルタ同期テーブルが使用する `ds_sk` および `ds_pk` レコードの形式が変更されます。有効にすると、`populateIndexFields` エントリの処理も有効になります。
+ `item: Partial` (必須)
DynamoDB に配置される項目の残りの属性です。
+ `key: DynamoDBKey` (必須)
Put が実行される DynamoDB 内の項目のキーを指定する必須パラメータ。DynamoDB の項目には、単一のハッシュキーとソートキーが含まれています。
+ `populateIndexFields?: boolean` (オプション)
ブール値で、`customPartitionKey` と一緒に有効にすると、差分同期テーブル、具体的には `gsi_ds_pk` と `gsi_ds_sk` 列のレコードごとに新しいエントリが作成されます。詳細については、**「AWS AppSync デベロッパーガイド」の「[構成項目の配信](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html)」を参照してください。
**`Type QueryInput`**
```
QueryInput: ScanInput & {
query: DynamoDBKeyCondition>;
}
```
**タイプ宣言**
+ `query: DynamoDBKeyCondition>` (必須)
クエリする項目を記述するキー条件を指定します。特定のインデックスでは、パーティションキーの条件は等しく、ソートキーは比較または `beginsWith` (文字列の場合) でなければなりません。パーティションキーとソートキーでは、数値型と文字列型のみがサポートされています。
**例**
以下の `User` タイプを考えてみてください。
```
type User = {
id: string;
name: string;
age: number;
isVerified: boolean;
friendsIds: string[]
}
```
このクエリには`id`、`name`、`age` のフィールドのみを含めることができます。
```
const query: QueryInput = {
name: { eq: 'John' },
age: { gt: 20 },
}
```
**`Type RemoveInput`**
```
RemoveInput: {
_version?: number;
condition?: DynamoDBFilterObject;
customPartitionKey?: string;
key: DynamoDBKey;
populateIndexFields?: boolean;
}
```
**タイプ宣言**
+ `_version?: number` (オプション)
+ `condition?: DynamoDBFilterObject` (オプション)
DynamoDB テーブルにオブジェクトを格納する際、オプションで条件式を指定することができます。この条件式は、操作を実行する前にすでに DynamoDB に格納されているオブジェクトの状態に基づいて、リクエストを成功させるかどうかを制御します。
**例**
次の例は、ドキュメントの所有者がリクエストを行ったユーザーと一致する場合にのみ操作が成功することを許可する条件を含む `DeleteItem` 式です。
```
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` (オプション)
有効にすると、`customPartitionKey` 値によって、バージョニングが有効になっているときにデルタ同期テーブルが使用する `ds_sk` および `ds_pk` レコードの形式が変更されます。有効にすると、`populateIndexFields` エントリの処理も有効になります。
+ `key: DynamoDBKey` (必須)
削除する DynamoDB 内の項目のキーを指定する必須パラメータ。DynamoDB の項目には、単一のハッシュキーとソートキーが含まれています。
**例**
`User` がユーザー `id` のハッシュキーしか持っていない場合、キーは次のようになります。
```
type User = {
id: number
name: string
age: number
isVerified: boolean
}
const key: DynamoDBKey = {
id: 1,
}
```
テーブルユーザーがハッシュキー (`id`) とソートキー (`name`) を持っている場合、キーは以下のようになります。
```
type User = {
id: number
name: string
age: number
isVerified: boolean
friendsIds: string[]
}
const key: DynamoDBKey = {
id: 1,
name: 'XXXXXXXXXX',
}
```
+ `populateIndexFields?: boolean` (オプション)
ブール値で、`customPartitionKey` と一緒に有効にすると、差分同期テーブル、具体的には `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;
}
```
**タイプ宣言**
+ `consistentRead?: boolean | null` (オプション)
DynamoDB のクエリ時に一貫性のあるリードを示すオプションのブール値。デフォルト値は `false` です。
+ `filter?: DynamoDBFilterObject | null` (オプション)
テーブルから結果を取得した後に結果に適用するオプションのフィルター。
+ `index?: string | null` (オプション)
スキャンするインデックスの名前。
+ `limit?: number | null` (オプション)
返される結果の最大数。
+ `nextToken?: string | null` (オプション)
前のクエリを継続するためのオプションのページ分割トークンです。これは前のクエリから取得されます。
+ `scanIndexForward?: boolean | null` (オプション)
クエリを昇順にするか、降順にするかを示すオプションのブール値。デフォルトではこの値は `true` に設定されます。
+ `segment?: number` (オプション)
+ `select?: DynamoDBSelectAttributes` (オプション)
DynamoDB から返される属性。デフォルトでは、 AWS AppSync DynamoDB リゾルバーはインデックスに射影された属性のみを返します。サポートされている値には以下があります。
+ `ALL_ATTRIBUTES`
指定されたテーブルまたはインデックスのすべての項目の属性を返します。ローカルセカンダリインデックスに対してクエリを実行する場合、DynamoDB は、親のテーブルからインデックスの項目に一致したすべての項目をフェッチします。インデックスがすべての項目の属性を射影するように設定されている場合、すべてのデータはローカルセカンダリインデックスから取得されるため、フェッチは必要ありません。
+ `ALL_PROJECTED_ATTRIBUTES`
インデックスにプロジェクションされたすべての属性を取得します。インデックスがすべての属性を投射するように設定されている場合、この返り値は `ALL_ATTRIBUTES` を指定した場合と同等になります。
+ `SPECIFIC_ATTRIBUTES`
`ProjectionExpression` にリストされている属性のみを返します。この戻り値は、`AttributesToGet` の値を指定せずに `ProjectionExpression` を指定することと同じです。
+ `totalSegments?: number` (オプション)
**`Type DynamoDBSyncInput`**
```
DynamoDBSyncInput: {
basePartitionKey?: string;
deltaIndexName?: string;
filter?: DynamoDBFilterObject | null;
lastSync?: number;
limit?: number | null;
nextToken?: string | null;
}
```
**タイプ宣言**
+ `basePartitionKey?: string` (オプション)
Sync 操作を実行するときに使用するベーステーブルのパーティションキー。このフィールドにより、テーブルがカスタムパーティションキーを使用している場合に Sync 操作を実行できます。
+ `deltaIndexName?: string` (オプション)
Sync 操作に使用されるインデックス。このインデックスは、テーブルがカスタムパーティションキーを使用する場合に、デルタストアテーブル全体で Sync 操作を有効にするために必要です。Sync オペレーションは GSI (`gsi_ds_pk` と `gsi_ds_sk` で作成) で実行されます。
+ `filter?: DynamoDBFilterObject | null` (オプション)
テーブルから結果を取得した後に結果に適用するオプションのフィルター。
+ `lastSync?: number` (オプション)
最後に成功した Sync オペレーションが開始されたエポックミリ秒単位の時刻。指定すると、`lastSync` 以降に変更された項目のみが返されます。このフィールドはオプションです。最初の Sync オペレーションからすべてのページを取得した後にのみ入力する必要があります。省略すると、ベーステーブルの結果が返されます。それ以外の場合は、差分テーブルの結果が返されます。
+ `limit?: number | null` (オプション)
一度に評価する項目の最大数です。省略した場合、デフォルトの制限は `100` 項目に設定されます。このフィールドの最大値は `1000` 項目です。
+ `nextToken?: string | null` (オプション)
**`Type DynamoDBUpdateInput`**
```
DynamoDBUpdateInput: {
_version?: number;
condition?: DynamoDBFilterObject;
customPartitionKey?: string;
key: DynamoDBKey;
populateIndexFields?: boolean;
update: DynamoDBUpdateObject;
}
```
**タイプ宣言**
+ `_version?: number` (オプション)
+ `condition?: DynamoDBFilterObject` (オプション)
DynamoDB でオブジェクトを更新する場合、オプションで条件式を指定することができます。この条件式は、操作を実行する前にすでに DynamoDB にあるオブジェクトの状態に基づいて、リクエストを成功させるかどうかを制御します。
+ `customPartitionKey?: string` (オプション)
有効にすると、`customPartitionKey` 値によって、バージョニングが有効になっているときにデルタ同期テーブルが使用する `ds_sk` および `ds_pk` レコードの形式が変更されます。有効にすると、`populateIndexFields` エントリの処理も有効になります。
+ `key: DynamoDBKey` (必須)
更新中の DynamoDB 内の項目のキーを指定する必須パラメータ。DynamoDB の項目には、単一のハッシュキーとソートキーが含まれています。
+ `populateIndexFields?: boolean` (オプション)
ブール値で、`customPartitionKey` と一緒に有効にすると、差分同期テーブル、具体的には `gsi_ds_pk` と `gsi_ds_sk` 列のレコードごとに新しいエントリが作成されます。
+ `update: DynamoDBUpdateObject`
更新する属性とその新しい値を指定するオブジェクト。更新オブジェクトは `add`、`remove`、`replace`、`increment`、`decrement`、`append`、`prepend`、`updateListItem` と共に使用できます。
## Amazon RDS モジュール関数
Amazon RDS モジュール関数を使用すると、Amazon RDS Data API で設定されたデータベースを操作する際のエクスペリエンスが向上します。モジュールは `@aws-appsync/utils/rds` を使用してインポートされます。
```
import * as rds from '@aws-appsync/utils/rds';
```
関数は個別にインポートすることもできます。例えば、以下のインポートでは `sql` を使用します。
```
import { sql } from '@aws-appsync/utils/rds';
```
### 関数
AWS AppSync RDS モジュールのユーティリティヘルパーを使用して、データベースとやり取りできます。
#### Select
`select` ユーティリティは、リレーショナルデータベースにクエリを実行する `SELECT` ステートメントを作成します。
**基本的な使用法**
基本的な形式では、クエリを実行するテーブルを指定できます。
```
import { select, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
// Generates statement:
// "SELECT * FROM "persons"
return createPgStatement(select({table: 'persons'}));
}
```
なお、テーブル識別子でスキーマを指定することもできます。
```
import { select, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
// Generates statement:
// SELECT * FROM "private"."persons"
return createPgStatement(select({table: 'private.persons'}));
}
```
**列の指定**
`columns` プロパティで列を指定できます。これを値に設定しない場合、デフォルトでは `*` になります。
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name']
}));
}
```
また、列のテーブルも指定できます。
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "persons"."name"
// FROM "persons"
return createPgStatement(select({
table: 'persons',
columns: ['id', 'persons.name']
}));
}
```
**LIMIT と OFFSET**
`limit` と `offset` をクエリに適用できます。
```
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
}));
}
```
**ORDER BY**
結果は `orderBy` プロパティを使用してソートできます。列とオプションの `dir` プロパティを指定するオブジェクトの配列を指定します。
```
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'}]
}));
}
```
**フィルター**
特殊条件オブジェクトを使用してフィルターを構築できます。
```
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'}}
}));
}
```
以下のフィルターを組み合わせることもできます。
```
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}}
}));
}
```
また、`OR` ステートメントも作成できます。
```
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 } }
]}
}));
}
```
`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 } }
]}
}));
}
```
以下の演算子を使用して、値を比較することもできます。
|
|
| 演算子 | 説明 | 可能な値型 |
| --- |--- |--- |
| eq | Equal | number, string, boolean |
| ne | Not equal | number, string, boolean |
| le | Less than or equal | number, string |
| lt | Less than | number, string |
| ge | Greater than or equal | number, string |
| gt | Greater than | number, string |
| contains | Like | string |
| notContains | Not like | string |
| beginsWith | Starts with prefix | string |
| between | Between two values | number, string |
| attributeExists | The attribute is not null | number, string, boolean |
| size | checks the length of the element | string |
#### Insert
`insert` ユーティリティによって、`INSERT` オペレーションを使用してデータベースに単一行の項目を簡単に挿入できます。
**単一項目の挿入**
項目を挿入するには、テーブルを指定して、値のオブジェクトを渡します。オブジェクトキーはテーブルの列にマッピングされます。列名は自動的にエスケープされ、値は変数マップを使用してデータベースに送信されます。
```
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)
}
```
**MySQL ユースケース**
`insert` の後に `select` を組み合わせて、挿入した行を取得できます。
```
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)
}
```
**Postgres のユースケース**
Postgres では、[https://www.postgresql.org/docs/current/dml-returning.html](https://www.postgresql.org/docs/current/dml-returning.html) を使用して、挿入した行からデータを取得できます。`*` または列名の配列が受け入れられます。
```
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)
}
```
#### 更新
`update` ユーティリティでは、既存の行を更新できます。条件オブジェクトを使用すると、条件を満たすすべての行の指定された列に変更を適用できます。例えば、このミューテーションを可能にするスキーマがあるとします。`Person` の `name` を `3` の `id` 値で更新したいのですが、これは `2000` 年以降にそれら (`known_since`) がわかっている場合に限ります。
```
mutation Update {
updatePerson(
input: {id: 3, name: "Jon"},
condition: {known_since: {ge: "2000"}}
) {
id
name
}
}
```
更新リゾルバーは以下のようになります。
```
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)
}
```
条件にチェックを追加して、`3` と等しいプライマリキー `id` を持つ行だけが更新されるようにすることができます。同様に、Postgres `inserts` の場合も、`returning` を使用して変更されたデータを返すことができます。
#### 削除
`remove` ユーティリティでは、既存の行を削除できます。条件オブジェクトは、条件を満たすすべての行で使用できます。なお、`delete` はJavaScriptの予約キーワードです。代わりに `remove` を使ってください。
```
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)
}
```
### キャスティング
ステートメントで使用する正しいオブジェクト型に関して、さらに特異度が必要となる場合もあるでしょう。指定された型ヒントを使用してパラメータのタイプを指定できます。 は Data API [と同じ型ヒント](https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_SqlParameter.html#rdsdtataservice-Type-SqlParameter-typeHint) AWS AppSync をサポートします。モジュールの `typeHint`関数を使用してパラメータを AWS AppSync `rds`キャストできます。
次の例では、JSON オブジェクトとしてキャストされた値として配列を送信できます。`->` 演算子を使用して JSON 配列内にある `index` `2` の要素を取得します。
```
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
}
```
キャスティングは、`DATE`、`TIME`、`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)
}
```
現在の日付と時刻を送信する方法について別の例を以下に示します。
```
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)}`)
}
```
**使用可能な型ヒント**
+ `typeHint.DATE` - 対応するパラメータが、`DATE` 型のオブジェクトとしてデータベースに送信されます。受け入れられる形式は `YYYY-MM-DD` です。
+ `typeHint.DECIMAL` - 対応するパラメータが、`DECIMAL` 型のオブジェクトとしてデータベースに送信されます。
+ `typeHint.JSON` - 対応するパラメータが、`JSON` 型のオブジェクトとしてデータベースに送信されます。
+ `typeHint.TIME` - 対応する文字列パラメータ値が、`TIME` 型のオブジェクトとしてデータベースに送信されます。受け入れられる形式は `HH:MM:SS[.FFF]` です。
+ `typeHint.TIMESTAMP` - 対応する文字列パラメータ値が、`TIMESTAMP` 型のオブジェクトとしてデータベースに送信されます。受け入れられる形式は `YYYY-MM-DD HH:MM:SS[.FFF]` です。
+ `typeHint.UUID` - 対応する文字列パラメータ値が、`UUID` 型のオブジェクトとしてデータベースに送信されます。
# ランタイムユーティリティ
`runtime` ライブラリには、リゾルバーと関数のランタイムプロパティを制御または変更するためのユーティリティが用意されています。
## ランタイム utils リスト
**`runtime.earlyReturn(obj?: unknown, returnOptions?: {skipTo: 'END' | 'NEXT'}): never`**
この関数を呼び出すと、現在のコンテキストに応じて、現在のハンドラー、 AWS AppSync 関数、またはリゾルバー (ユニットまたはパイプラインリゾルバー) の実行が停止します。指定したオブジェクトが結果として返されます。
+ AWS AppSync 関数リクエストハンドラーで呼び出されると、データソースハンドラーとレスポンスハンドラーはスキップされ、次の関数リクエストハンドラー (または最後の AWS AppSync 関数の場合はパイプラインリゾルバーレスポンスハンドラー) が呼び出されます。
+ AWS AppSync パイプラインリゾルバーリクエストハンドラーで呼び出されると、パイプラインの実行はスキップされ、パイプラインリゾルバーレスポンスハンドラーはすぐに呼び出されます。
+ `returnOptions` を「END」に `skipTo` 設定すると、パイプラインの実行はスキップされ、パイプラインリゾルバーレスポンスハンドラーは即座に呼び出されます。
+ `returnOptions` を「NEXT」に `skipTo` 設定すると、関数の実行はスキップされ、次のパイプラインハンドラーが呼び出されます。
**例**
```
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
}
```
# util.time の日時ヘルパー
`util.time` 変数には、タイムスタンプの生成、日時形式間の変換、および日時文字列の解析に役立つ日時メソッドが含まれています。日時形式の構文は Java の DateTimeFormatter に基づいています。詳細については、[DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html) を参照してください。
## 日時 utils リスト
**`util.time.nowISO8601()`**
[ISO 8601 形式](https://en.wikipedia.org/wiki/ISO_8601)の UTC の文字列型表現を返します。
**`util.time.nowEpochSeconds()`**
エポック (1970-01-01T00:00:00Z) から現在までの秒数を返します。
**`util.time.nowEpochMilliSeconds()`**
エポック (1970-01-01T00:00:00Z) から現在までのミリ秒数を返します。
**`util.time.nowFormatted(String)`**
文字列型の入力引数で指定された形式を使用して、UTC での現在のタイムスタンプを返します。
**`util.time.nowFormatted(String, String)`**
文字列型の入力引数で指定された形式とタイムゾーンを使用して、そのタイムゾーンでの現在のタイムスタンプを返します。
**`util.time.parseFormattedToEpochMilliSeconds(String, String)`**
文字列として、タイムゾーンを含む形式で渡されたタイムスタンプを解析し、エポックからのミリ秒単位のタイムスタンプを返します。
**`util.time.parseFormattedToEpochMilliSeconds(String, String, String)`**
文字列型として渡されたタイムスタンプ、形式、およびタイムゾーンを解析し、エポックからのミリ秒単位のタイムスタンプを返します。
**`util.time.parseISO8601ToEpochMilliSeconds(String)`**
文字列型として渡された ISO8601 形式のタイムスタンプを解析し、エポックからのミリ秒単位のタイムスタンプを返します。
**`util.time.epochMilliSecondsToSeconds(long)`**
エポックからのミリ秒単位のタイムスタンプを、エポックからの秒単位のタイムスタンプに変換します。
**`util.time.epochMilliSecondsToISO8601(long)`**
エポックからのミリ秒単位のタイムスタンプを、ISO8601 形式のタイムスタンプに変換します。
**`util.time.epochMilliSecondsToFormatted(long, String)`**
long として渡されたエポックからのミリ秒単位のタイムスタンプを、文字列型で指定された形式に合わせて UTC でのタイムスタンプに変換します。
**`util.time.epochMilliSecondsToFormatted(long, String, String)`**
long として渡されたエポックからのミリ秒単位のタイムスタンプを、文字列型で指定された形式とタイムゾーンに合わせて、そのタイムゾーンでのタイムスタンプに変換します。
# util.dynamodb の DynamoDB ヘルパー
`util.dynamodb` には、Amazon DynamoDB に対するデータの読み書きを容易にするヘルパーメソッド (自動型マッピングやフォーマットなど) が含まれています。
## toDynamoDB
### toDynamoDB utils リスト
**`util.dynamodb.toDynamoDB(Object)`**
入力されたオブジェクトを適切な DynamoDB 表現形式に変換する DynamoDB 用の一般的なオブジェクト変換ツールです。このツールは、一部の型の表現方法に関して融通が利きません。例えば、セット型 ("SS"、"NS"、"BS") ではなくリスト型 ("L") が使用されます。これは、DynamoDB 属性値を記述するオブジェクトを返します。
**文字列型の例**
```
Input: util.dynamodb.toDynamoDB("foo")
Output: { "S" : "foo" }
```
**数値型の例**
```
Input: util.dynamodb.toDynamoDB(12345)
Output: { "N" : 12345 }
```
**ブール型の例**
```
Input: util.dynamodb.toDynamoDB(true)
Output: { "BOOL" : true }
```
**リスト型の例**
```
Input: util.dynamodb.toDynamoDB([ "foo", 123, { "bar" : "baz" } ])
Output: {
"L" : [
{ "S" : "foo" },
{ "N" : 123 },
{
"M" : {
"bar" : { "S" : "baz" }
}
}
]
}
```
**マップ型の例**
```
Input: util.dynamodb.toDynamoDB({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] })
Output: {
"M" : {
"foo" : { "S" : "bar" },
"baz" : { "N" : 1234 },
"beep" : {
"L" : [
{ "S" : "boop" }
]
}
}
}
```
## toString utils
### toString utils リスト
**`util.dynamodb.toString(String)`**
入力文字列を DynamoDB の文字列形式に変換します。これは、DynamoDB 属性値を記述するオブジェクトを返します。
```
Input: util.dynamodb.toString("foo")
Output: { "S" : "foo" }
```
**`util.dynamodb.toStringSet(List)`**
文字列型のリスト型を DynamoDB の文字列セット形式に変換します。これは、DynamoDB 属性値を記述するオブジェクトを返します。
```
Input: util.dynamodb.toStringSet([ "foo", "bar", "baz" ])
Output: { "SS" : [ "foo", "bar", "baz" ] }
```
## toNumber utils
### toNumber utils リスト
**`util.dynamodb.toNumber(Number)`**
数値を DynamoDB の数値形式に変換します。これは、DynamoDB 属性値を記述するオブジェクトを返します。
```
Input: util.dynamodb.toNumber(12345)
Output: { "N" : 12345 }
```
**`util.dynamodb.toNumberSet(List)`**
数値のリストを DynamoDB の数値セット形式に変換します。これは、DynamoDB 属性値を記述するオブジェクトを返します。
```
Input: util.dynamodb.toNumberSet([ 1, 23, 4.56 ])
Output: { "NS" : [ 1, 23, 4.56 ] }
```
## toBinary utils
### toBinary utils リスト
**`util.dynamodb.toBinary(String)`**
base64 文字列としてエンコードされたバイナリデータを DynamoDB のバイナリ形式に変換します。これは、DynamoDB 属性値を記述するオブジェクトを返します。
```
Input: util.dynamodb.toBinary("foo")
Output: { "B" : "foo" }
```
**`util.dynamodb.toBinarySet(List)`**
base64 文字列としてエンコードされたバイナリデータのリストを DynamoDB のバイナリセット形式に変換します。これは、DynamoDB 属性値を記述するオブジェクトを返します。
```
Input: util.dynamodb.toBinarySet([ "foo", "bar", "baz" ])
Output: { "BS" : [ "foo", "bar", "baz" ] }
```
## toBoolean utils
### toBoolean utils リスト
**`util.dynamodb.toBoolean(Boolean)`**
ブール値を DynamoDB の該当するブール形式に変換します。これは、DynamoDB 属性値を記述するオブジェクトを返します。
```
Input: util.dynamodb.toBoolean(true)
Output: { "BOOL" : true }
```
## toNull utils
### toNull utils リスト
**`util.dynamodb.toNull()`**
null を DynamoDB の null 形式で返します。これは、DynamoDB 属性値を記述するオブジェクトを返します。
```
Input: util.dynamodb.toNull()
Output: { "NULL" : null }
```
## toList utils
### toList utils リスト
**`util.dynamodb.toList(List)`**
オブジェクトのリストを DynamoDB のリスト形式に変換します。リスト内の各項目も、該当する DynamoDB 形式に変換されます。このツールは、一部のネステッドオブジェクトの表現方法に関して融通が利きません。例えば、セット型 ("SS"、"NS"、"BS") ではなくリスト型 ("L") が使用されます。これは、DynamoDB 属性値を記述するオブジェクトを返します。
```
Input: util.dynamodb.toList([ "foo", 123, { "bar" : "baz" } ])
Output: {
"L" : [
{ "S" : "foo" },
{ "N" : 123 },
{
"M" : {
"bar" : { "S" : "baz" }
}
}
]
}
```
## toMap utils
### toMap utils リスト
**`util.dynamodb.toMap(Map)`**
マップを DynamoDB のマップ形式に変換します。マップ内の各値も、該当する DynamoDB 形式に変換されます。このツールは、一部のネステッドオブジェクトの表現方法に関して融通が利きません。例えば、セット型 ("SS"、"NS"、"BS") ではなくリスト型 ("L") が使用されます。これは、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)`**
マップ内の各値を該当する DynamoDB 形式に変換して、マップのコピーを作成します。このツールは、一部のネステッドオブジェクトの表現方法に関して融通が利きません。例えば、セット型 ("SS"、"NS"、"BS") ではなくリスト型 ("L") が使用されます。
```
Input: util.dynamodb.toMapValues({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] })
Output: {
"foo" : { "S" : "bar" },
"baz" : { "N" : 1234 },
"beep" : {
"L" : [
{ "S" : "boop" }
]
}
}
```
注 : このツールは `util.dynamodb.toMap(Map)` と少し異なっていて、属性値全体ではなく DynamoDB の属性値の内容のみを返します。例えば、次の 2 つのステートメントはまったく同じです。
```
util.dynamodb.toMapValues(