The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import * as DynamoDB from "@alchemy.run/aws/DynamoDB"; |
| 2 | import * as Lambda from "@alchemy.run/aws/Lambda"; |
| 3 | import * as S3 from "@alchemy.run/aws/S3"; |
| 4 | import * as Effect from "effect/Effect"; |
| 5 | import { HttpServerRequest } from "effect/http/HttpServerRequest"; |
| 6 | import * as HttpServerResponse from "effect/http/HttpServerResponse"; |
| 7 | import * as Layer from "effect/Layer"; |
| 8 | import path from "pathe"; |
| 9 | |
| 10 | const main = path.resolve(import.meta.dirname, "handler.ts"); |
| 11 | |
| 12 | export class DynamoDBTestFunction extends Lambda.Function<Lambda.Function>()( |
| 13 | "DynamoDBTestFunction", |
| 14 | ) {} |
| 15 | |
| 16 | export default DynamoDBTestFunction.make( |
| 17 | { |
| 18 | main, |
| 19 | functionUrl: true, |
| 20 | }, |
| 21 | Effect.gen(function* () { |
| 22 | const sourceTable = yield* DynamoDB.Table("TestTable", { |
| 23 | partitionKey: "pk", |
| 24 | sortKey: "sk", |
| 25 | attributes: { |
| 26 | pk: "S", |
| 27 | sk: "S", |
| 28 | category: "S", |
| 29 | subcategory: "S", |
| 30 | rank: "S", |
| 31 | }, |
| 32 | globalSecondaryIndexes: [ |
| 33 | { |
| 34 | // Multi-attribute keys: composite partition key (category + |
| 35 | // subcategory) and composite sort key (rank + sk). Sparse — only |
| 36 | // items written with all four attributes appear in the index. |
| 37 | indexName: "MultiAttrIndex", |
| 38 | partitionKey: ["category", "subcategory"], |
| 39 | sortKey: ["rank", "sk"], |
| 40 | projection: { ProjectionType: "ALL" }, |
| 41 | }, |
| 42 | ], |
| 43 | }); |
| 44 | const restoreTargetTable = yield* DynamoDB.Table("RestoreTargetTable", { |
| 45 | partitionKey: "pk", |
| 46 | sortKey: "sk", |
| 47 | attributes: { pk: "S", sk: "S" }, |
| 48 | }); |
| 49 | const exportBucket = yield* S3.Bucket("ExportBucket", { |
| 50 | forceDestroy: true, |
| 51 | }); |
| 52 | |
| 53 | const getItem = yield* DynamoDB.GetItem(sourceTable); |
| 54 | const batchGetItem = yield* DynamoDB.BatchGetItem(sourceTable); |
| 55 | const batchWriteItem = yield* DynamoDB.BatchWriteItem(sourceTable); |
| 56 | const batchExecuteStatement = yield* DynamoDB.BatchExecuteStatement(sourceTable); |
| 57 | const describeTable = yield* DynamoDB.DescribeTable(sourceTable); |
| 58 | const describeTimeToLive = yield* DynamoDB.DescribeTimeToLive(sourceTable); |
| 59 | const executeStatement = yield* DynamoDB.ExecuteStatement(sourceTable); |
| 60 | const executeTransaction = yield* DynamoDB.ExecuteTransaction(sourceTable); |
| 61 | const putItem = yield* DynamoDB.PutItem(sourceTable); |
| 62 | const deleteItem = yield* DynamoDB.DeleteItem(sourceTable); |
| 63 | const listTables = yield* DynamoDB.ListTables(); |
| 64 | const listTagsOfResource = yield* DynamoDB.ListTagsOfResource(sourceTable); |
| 65 | const updateItem = yield* DynamoDB.UpdateItem(sourceTable); |
| 66 | const updateTimeToLive = yield* DynamoDB.UpdateTimeToLive(sourceTable); |
| 67 | const query = yield* DynamoDB.Query(sourceTable); |
| 68 | const scan = yield* DynamoDB.Scan(sourceTable); |
| 69 | const TableName = yield* sourceTable.tableName; |
| 70 | const restoreTableToPointInTime = yield* DynamoDB.RestoreTableToPointInTime( |
| 71 | sourceTable, |
| 72 | restoreTargetTable, |
| 73 | ); |
| 74 | const transactGetItems = yield* DynamoDB.TransactGetItems(sourceTable); |
| 75 | const transactWriteItems = yield* DynamoDB.TransactWriteItems(sourceTable); |
| 76 | const createBackup = yield* DynamoDB.CreateBackup(sourceTable); |
| 77 | const describeBackup = yield* DynamoDB.DescribeBackup(sourceTable); |
| 78 | const listBackups = yield* DynamoDB.ListBackups(sourceTable); |
| 79 | const deleteBackup = yield* DynamoDB.DeleteBackup(sourceTable); |
| 80 | const describeContinuousBackups = yield* DynamoDB.DescribeContinuousBackups(sourceTable); |
| 81 | const restoreTableFromBackup = yield* DynamoDB.RestoreTableFromBackup( |
| 82 | sourceTable, |
| 83 | restoreTargetTable, |
| 84 | ); |
| 85 | const exportTableToPointInTime = yield* DynamoDB.ExportTableToPointInTime( |
| 86 | sourceTable, |
| 87 | exportBucket, |
| 88 | ); |
| 89 | const describeExport = yield* DynamoDB.DescribeExport(sourceTable); |
| 90 | const listExports = yield* DynamoDB.ListExports(sourceTable); |
| 91 | |
| 92 | return { |
| 93 | fetch: Effect.gen(function* () { |
| 94 | const request = yield* HttpServerRequest; |
| 95 | const url = new URL(request.originalUrl); |
| 96 | const pathname = url.pathname; |
| 97 | |
| 98 | yield* Effect.logInfo( |
| 99 | `Request: ${request.method} ${pathname} (originalUrl: ${request.originalUrl}, url: ${request.url})`, |
| 100 | ); |
| 101 | |
| 102 | if (request.method === "POST" && pathname === "/put") { |
| 103 | const body = (yield* request.json) as unknown as { |
| 104 | pk: string; |
| 105 | sk: string; |
| 106 | data?: string; |
| 107 | category?: string; |
| 108 | subcategory?: string; |
| 109 | rank?: string; |
| 110 | }; |
| 111 | const result = yield* putItem({ |
| 112 | Item: { |
| 113 | pk: { S: body.pk }, |
| 114 | sk: { S: body.sk }, |
| 115 | ...(body.data ? { data: { S: body.data } } : {}), |
| 116 | // Natural attributes indexed by the multi-attribute-key GSI — |
| 117 | // no synthetic concatenated keys. |
| 118 | ...(body.category ? { category: { S: body.category } } : {}), |
| 119 | ...(body.subcategory ? { subcategory: { S: body.subcategory } } : {}), |
| 120 | ...(body.rank ? { rank: { S: body.rank } } : {}), |
| 121 | }, |
| 122 | }); |
| 123 | return yield* HttpServerResponse.json({ success: true, result }); |
| 124 | } |
| 125 | |
| 126 | if (request.method === "GET" && pathname === "/get") { |
| 127 | const pk = url.searchParams.get("pk"); |
| 128 | const sk = url.searchParams.get("sk"); |
| 129 | if (!pk || !sk) { |
| 130 | return HttpServerResponse.text("Missing pk or sk", { status: 400 }); |
| 131 | } |
| 132 | const result = yield* getItem({ |
| 133 | Key: { |
| 134 | pk: { S: pk }, |
| 135 | sk: { S: sk }, |
| 136 | }, |
| 137 | }); |
| 138 | return yield* HttpServerResponse.json({ item: result.Item }); |
| 139 | } |
| 140 | |
| 141 | if (request.method === "GET" && pathname === "/describe-table") { |
| 142 | const result = yield* describeTable(); |
| 143 | return yield* HttpServerResponse.json({ |
| 144 | table: result.Table, |
| 145 | }); |
| 146 | } |
| 147 | |
| 148 | if (request.method === "GET" && pathname === "/describe-ttl") { |
| 149 | const result = yield* describeTimeToLive(); |
| 150 | return yield* HttpServerResponse.json({ |
| 151 | timeToLiveDescription: result.TimeToLiveDescription, |
| 152 | }); |
| 153 | } |
| 154 | |
| 155 | if (request.method === "DELETE" && pathname === "/delete") { |
| 156 | const body = (yield* request.json) as unknown as { |
| 157 | pk: string; |
| 158 | sk: string; |
| 159 | }; |
| 160 | const result = yield* deleteItem({ |
| 161 | Key: { |
| 162 | pk: { S: body.pk }, |
| 163 | sk: { S: body.sk }, |
| 164 | }, |
| 165 | }); |
| 166 | return yield* HttpServerResponse.json({ success: true, result }); |
| 167 | } |
| 168 | |
| 169 | if (request.method === "POST" && pathname === "/update") { |
| 170 | const body = (yield* request.json) as unknown as { |
| 171 | pk: string; |
| 172 | sk: string; |
| 173 | data: string; |
| 174 | }; |
| 175 | const result = yield* updateItem({ |
| 176 | Key: { |
| 177 | pk: { S: body.pk }, |
| 178 | sk: { S: body.sk }, |
| 179 | }, |
| 180 | UpdateExpression: "SET #data = :data", |
| 181 | ExpressionAttributeNames: { "#data": "data" }, |
| 182 | ExpressionAttributeValues: { ":data": { S: body.data } }, |
| 183 | ReturnValues: "ALL_NEW", |
| 184 | }); |
| 185 | return yield* HttpServerResponse.json({ |
| 186 | success: true, |
| 187 | attributes: result.Attributes, |
| 188 | }); |
| 189 | } |
| 190 | |
| 191 | if (request.method === "POST" && pathname === "/update-ttl") { |
| 192 | const body = (yield* request.json) as unknown as { |
| 193 | attributeName: string; |
| 194 | enabled: boolean; |
| 195 | }; |
| 196 | const result = yield* updateTimeToLive({ |
| 197 | TimeToLiveSpecification: { |
| 198 | AttributeName: body.attributeName, |
| 199 | Enabled: body.enabled, |
| 200 | }, |
| 201 | }); |
| 202 | return yield* HttpServerResponse.json({ |
| 203 | timeToLiveSpecification: result.TimeToLiveSpecification, |
| 204 | }); |
| 205 | } |
| 206 | |
| 207 | if (request.method === "POST" && pathname === "/batch-write") { |
| 208 | const body = (yield* request.json) as unknown as DynamoDB.BatchWriteItemRequest; |
| 209 | const result = yield* batchWriteItem(body); |
| 210 | return yield* HttpServerResponse.json({ |
| 211 | unprocessedItems: result.UnprocessedItems ?? {}, |
| 212 | }); |
| 213 | } |
| 214 | |
| 215 | if (request.method === "POST" && pathname === "/batch-get") { |
| 216 | const body = (yield* request.json) as unknown as DynamoDB.BatchGetItemRequest; |
| 217 | const result = yield* batchGetItem(body); |
| 218 | return yield* HttpServerResponse.json({ |
| 219 | responses: result.Responses ?? {}, |
| 220 | unprocessedKeys: result.UnprocessedKeys ?? {}, |
| 221 | }); |
| 222 | } |
| 223 | |
| 224 | if (request.method === "POST" && pathname === "/transact-write") { |
| 225 | const body = (yield* request.json) as unknown as DynamoDB.TransactWriteItemsRequest; |
| 226 | const result = yield* transactWriteItems(body); |
| 227 | return yield* HttpServerResponse.json({ |
| 228 | success: true, |
| 229 | result, |
| 230 | }); |
| 231 | } |
| 232 | |
| 233 | if (request.method === "POST" && pathname === "/transact-get") { |
| 234 | const body = (yield* request.json) as unknown as DynamoDB.TransactGetItemsRequest; |
| 235 | const result = yield* transactGetItems(body); |
| 236 | return yield* HttpServerResponse.json({ |
| 237 | responses: result.Responses ?? [], |
| 238 | }); |
| 239 | } |
| 240 | |
| 241 | if (request.method === "POST" && pathname === "/execute-transaction") { |
| 242 | const tableName = yield* TableName; |
| 243 | const result = yield* executeTransaction({ |
| 244 | TransactStatements: [ |
| 245 | { |
| 246 | Statement: `SELECT * FROM "${tableName}" WHERE pk=? AND sk=?`, |
| 247 | Parameters: [{ S: "tx#1" }, { S: "item1" }], |
| 248 | }, |
| 249 | { |
| 250 | Statement: `SELECT * FROM "${tableName}" WHERE pk=? AND sk=?`, |
| 251 | Parameters: [{ S: "tx#1" }, { S: "item2" }], |
| 252 | }, |
| 253 | ], |
| 254 | }); |
| 255 | return yield* HttpServerResponse.json({ |
| 256 | responses: result.Responses, |
| 257 | }); |
| 258 | } |
| 259 | |
| 260 | if (request.method === "POST" && pathname === "/execute-statement") { |
| 261 | const body = (yield* request.json) as unknown as { |
| 262 | pk: string; |
| 263 | sk: string; |
| 264 | }; |
| 265 | const tableName = yield* TableName; |
| 266 | const result = yield* executeStatement({ |
| 267 | Statement: `SELECT * FROM "${tableName}" WHERE pk=? AND sk=?`, |
| 268 | Parameters: [{ S: body.pk }, { S: body.sk }], |
| 269 | }); |
| 270 | return yield* HttpServerResponse.json({ |
| 271 | items: result.Items ?? [], |
| 272 | }); |
| 273 | } |
| 274 | |
| 275 | if (request.method === "POST" && pathname === "/batch-execute-statement") { |
| 276 | const body = (yield* request.json) as unknown as { |
| 277 | first: { pk: string; sk: string }; |
| 278 | second: { pk: string; sk: string }; |
| 279 | }; |
| 280 | const sourceTableName = yield* TableName; |
| 281 | const result = yield* batchExecuteStatement({ |
| 282 | Statements: [ |
| 283 | { |
| 284 | Statement: `SELECT * FROM "${sourceTableName}" WHERE pk=? AND sk=?`, |
| 285 | Parameters: [{ S: body.first.pk }, { S: body.first.sk }], |
| 286 | }, |
| 287 | { |
| 288 | Statement: `SELECT * FROM "${sourceTableName}" WHERE pk=? AND sk=?`, |
| 289 | Parameters: [{ S: body.second.pk }, { S: body.second.sk }], |
| 290 | }, |
| 291 | ], |
| 292 | }); |
| 293 | return yield* HttpServerResponse.json({ |
| 294 | responses: result.Responses ?? [], |
| 295 | }); |
| 296 | } |
| 297 | |
| 298 | if (request.method === "POST" && pathname === "/restore-table") { |
| 299 | const result = yield* restoreTableToPointInTime({ |
| 300 | UseLatestRestorableTime: true, |
| 301 | }).pipe( |
| 302 | Effect.map((result) => ({ |
| 303 | ok: true as const, |
| 304 | result, |
| 305 | })), |
| 306 | Effect.catch((error) => |
| 307 | Effect.succeed({ |
| 308 | ok: false as const, |
| 309 | error: |
| 310 | typeof error === "object" && error !== null && "_tag" in error |
| 311 | ? (error as { _tag: string })._tag |
| 312 | : `${error}`, |
| 313 | }), |
| 314 | ), |
| 315 | ); |
| 316 | return yield* HttpServerResponse.json(result); |
| 317 | } |
| 318 | |
| 319 | if (request.method === "GET" && pathname === "/query") { |
| 320 | const pk = url.searchParams.get("pk"); |
| 321 | if (!pk) { |
| 322 | return HttpServerResponse.text("Missing pk", { status: 400 }); |
| 323 | } |
| 324 | const result = yield* query({ |
| 325 | KeyConditionExpression: "pk = :pk", |
| 326 | ExpressionAttributeValues: { ":pk": { S: pk } }, |
| 327 | }); |
| 328 | return yield* HttpServerResponse.json({ |
| 329 | items: result.Items, |
| 330 | count: result.Count, |
| 331 | }); |
| 332 | } |
| 333 | |
| 334 | if (request.method === "GET" && pathname === "/query-multi") { |
| 335 | const category = url.searchParams.get("category"); |
| 336 | const subcategory = url.searchParams.get("subcategory"); |
| 337 | const rank = url.searchParams.get("rank"); |
| 338 | if (!category || !subcategory) { |
| 339 | return HttpServerResponse.text("Missing category or subcategory", { |
| 340 | status: 400, |
| 341 | }); |
| 342 | } |
| 343 | // Multi-attribute-key GSI query: every partition attribute must be |
| 344 | // an equality condition; sort attributes narrow left-to-right. |
| 345 | const result = yield* query({ |
| 346 | IndexName: "MultiAttrIndex", |
| 347 | KeyConditionExpression: rank |
| 348 | ? "#c = :c AND #s = :s AND #r = :r" |
| 349 | : "#c = :c AND #s = :s", |
| 350 | ExpressionAttributeNames: { |
| 351 | "#c": "category", |
| 352 | "#s": "subcategory", |
| 353 | ...(rank ? { "#r": "rank" } : {}), |
| 354 | }, |
| 355 | ExpressionAttributeValues: { |
| 356 | ":c": { S: category }, |
| 357 | ":s": { S: subcategory }, |
| 358 | ...(rank ? { ":r": { S: rank } } : {}), |
| 359 | }, |
| 360 | }); |
| 361 | return yield* HttpServerResponse.json({ |
| 362 | items: result.Items, |
| 363 | count: result.Count, |
| 364 | }); |
| 365 | } |
| 366 | |
| 367 | if (request.method === "GET" && pathname === "/list-tables") { |
| 368 | const result = yield* listTables(); |
| 369 | return yield* HttpServerResponse.json({ |
| 370 | tableNames: result.TableNames, |
| 371 | }); |
| 372 | } |
| 373 | |
| 374 | if (request.method === "GET" && pathname === "/list-tags") { |
| 375 | const result = yield* listTagsOfResource(); |
| 376 | return yield* HttpServerResponse.json({ |
| 377 | tags: result.Tags, |
| 378 | }); |
| 379 | } |
| 380 | |
| 381 | if (request.method === "POST" && pathname === "/create-backup") { |
| 382 | const body = (yield* request.json) as unknown as { name: string }; |
| 383 | const result = yield* createBackup({ BackupName: body.name }); |
| 384 | return yield* HttpServerResponse.json({ |
| 385 | backupArn: result.BackupDetails?.BackupArn, |
| 386 | status: result.BackupDetails?.BackupStatus, |
| 387 | }); |
| 388 | } |
| 389 | |
| 390 | if (request.method === "GET" && pathname === "/describe-backup") { |
| 391 | const arn = url.searchParams.get("arn"); |
| 392 | if (!arn) { |
| 393 | return HttpServerResponse.text("Missing arn", { status: 400 }); |
| 394 | } |
| 395 | const result = yield* describeBackup({ BackupArn: arn }); |
| 396 | return yield* HttpServerResponse.json({ |
| 397 | status: result.BackupDescription?.BackupDetails?.BackupStatus, |
| 398 | }); |
| 399 | } |
| 400 | |
| 401 | if (request.method === "GET" && pathname === "/list-backups") { |
| 402 | const result = yield* listBackups(); |
| 403 | return yield* HttpServerResponse.json({ |
| 404 | backupArns: (result.BackupSummaries ?? []).map((summary) => summary.BackupArn), |
| 405 | }); |
| 406 | } |
| 407 | |
| 408 | if (request.method === "DELETE" && pathname === "/delete-backup") { |
| 409 | const body = (yield* request.json) as unknown as { arn: string }; |
| 410 | const result = yield* deleteBackup({ BackupArn: body.arn }).pipe( |
| 411 | Effect.map((output) => ({ |
| 412 | ok: true as const, |
| 413 | status: output.BackupDescription?.BackupDetails?.BackupStatus, |
| 414 | })), |
| 415 | Effect.catch((error) => Effect.succeed({ ok: false as const, error: error._tag })), |
| 416 | ); |
| 417 | return yield* HttpServerResponse.json(result); |
| 418 | } |
| 419 | |
| 420 | if (request.method === "GET" && pathname === "/describe-continuous-backups") { |
| 421 | const result = yield* describeContinuousBackups(); |
| 422 | return yield* HttpServerResponse.json({ |
| 423 | continuousBackupsStatus: result.ContinuousBackupsDescription?.ContinuousBackupsStatus, |
| 424 | pitrStatus: |
| 425 | result.ContinuousBackupsDescription?.PointInTimeRecoveryDescription |
| 426 | ?.PointInTimeRecoveryStatus, |
| 427 | }); |
| 428 | } |
| 429 | |
| 430 | if (request.method === "POST" && pathname === "/restore-from-backup") { |
| 431 | const body = (yield* request.json) as unknown as { arn: string }; |
| 432 | const result = yield* restoreTableFromBackup({ |
| 433 | BackupArn: body.arn, |
| 434 | }).pipe( |
| 435 | Effect.map((output) => ({ |
| 436 | ok: true as const, |
| 437 | status: output.TableDescription?.TableStatus, |
| 438 | })), |
| 439 | Effect.catch((error) => Effect.succeed({ ok: false as const, error: error._tag })), |
| 440 | ); |
| 441 | return yield* HttpServerResponse.json(result); |
| 442 | } |
| 443 | |
| 444 | if (request.method === "POST" && pathname === "/export-table") { |
| 445 | const result = yield* exportTableToPointInTime({ |
| 446 | ExportFormat: "DYNAMODB_JSON", |
| 447 | }).pipe( |
| 448 | Effect.map((output) => ({ |
| 449 | ok: true as const, |
| 450 | exportArn: output.ExportDescription?.ExportArn, |
| 451 | })), |
| 452 | Effect.catch((error) => Effect.succeed({ ok: false as const, error: error._tag })), |
| 453 | ); |
| 454 | return yield* HttpServerResponse.json(result); |
| 455 | } |
| 456 | |
| 457 | if (request.method === "GET" && pathname === "/list-exports") { |
| 458 | const result = yield* listExports(); |
| 459 | return yield* HttpServerResponse.json({ |
| 460 | exportArns: (result.ExportSummaries ?? []).map((summary) => summary.ExportArn), |
| 461 | }); |
| 462 | } |
| 463 | |
| 464 | if (request.method === "GET" && pathname === "/describe-export") { |
| 465 | const arn = url.searchParams.get("arn"); |
| 466 | if (!arn) { |
| 467 | return HttpServerResponse.text("Missing arn", { status: 400 }); |
| 468 | } |
| 469 | const result = yield* describeExport({ ExportArn: arn }).pipe( |
| 470 | Effect.map((output) => ({ |
| 471 | ok: true as const, |
| 472 | status: output.ExportDescription?.ExportStatus, |
| 473 | })), |
| 474 | Effect.catch((error) => Effect.succeed({ ok: false as const, error: error._tag })), |
| 475 | ); |
| 476 | return yield* HttpServerResponse.json(result); |
| 477 | } |
| 478 | |
| 479 | if (request.method === "GET" && pathname === "/scan") { |
| 480 | const result = yield* scan({}); |
| 481 | return yield* HttpServerResponse.json({ |
| 482 | items: result.Items, |
| 483 | count: result.Count, |
| 484 | }); |
| 485 | } |
| 486 | |
| 487 | return yield* HttpServerResponse.json( |
| 488 | { |
| 489 | error: "Not found", |
| 490 | method: request.method, |
| 491 | pathname, |
| 492 | url: request.url, |
| 493 | }, |
| 494 | { status: 404 }, |
| 495 | ); |
| 496 | }).pipe(Effect.orDie), |
| 497 | }; |
| 498 | }).pipe( |
| 499 | Effect.provide( |
| 500 | Layer.mergeAll( |
| 501 | DynamoDB.BatchExecuteStatementHttp, |
| 502 | DynamoDB.BatchGetItemHttp, |
| 503 | DynamoDB.BatchWriteItemHttp, |
| 504 | DynamoDB.CreateBackupHttp, |
| 505 | DynamoDB.DeleteBackupHttp, |
| 506 | DynamoDB.DescribeBackupHttp, |
| 507 | DynamoDB.DescribeContinuousBackupsHttp, |
| 508 | DynamoDB.DescribeExportHttp, |
| 509 | DynamoDB.ExportTableToPointInTimeHttp, |
| 510 | DynamoDB.ListBackupsHttp, |
| 511 | DynamoDB.ListExportsHttp, |
| 512 | DynamoDB.RestoreTableFromBackupHttp, |
| 513 | DynamoDB.DescribeTableHttp, |
| 514 | DynamoDB.DescribeTimeToLiveHttp, |
| 515 | DynamoDB.ExecuteStatementHttp, |
| 516 | DynamoDB.ExecuteTransactionHttp, |
| 517 | DynamoDB.GetItemHttp, |
| 518 | DynamoDB.ListTablesHttp, |
| 519 | DynamoDB.ListTagsOfResourceHttp, |
| 520 | DynamoDB.PutItemHttp, |
| 521 | DynamoDB.DeleteItemHttp, |
| 522 | DynamoDB.UpdateItemHttp, |
| 523 | DynamoDB.UpdateTimeToLiveHttp, |
| 524 | DynamoDB.QueryHttp, |
| 525 | DynamoDB.RestoreTableToPointInTimeHttp, |
| 526 | DynamoDB.ScanHttp, |
| 527 | DynamoDB.TransactGetItemsHttp, |
| 528 | DynamoDB.TransactWriteItemsHttp, |
| 529 | ), |
| 530 | ), |
| 531 | ), |
| 532 | ); |