@aws-sdk/lib-dynamodb 3.32.0 → 3.36.0

package/dist-cjs/commands/TransactWriteCommand.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactWriteCommand = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const utils_1 = require("../commands/utils");
+class TransactWriteCommand extends smithy_client_1.Command {
+    constructor(input) {
+        super();
+        this.input = input;
+        this.inputKeyNodes = [
+            {
+                key: "TransactItems",
+                children: [
+                    { key: "ConditionCheck", children: [{ key: "Key" }, { key: "ExpressionAttributeValues" }] },
+                    { key: "Put", children: [{ key: "Item" }, { key: "ExpressionAttributeValues" }] },
+                    { key: "Delete", children: [{ key: "Key" }, { key: "ExpressionAttributeValues" }] },
+                    { key: "Update", children: [{ key: "Key" }, { key: "ExpressionAttributeValues" }] },
+                ],
+            },
+        ];
+        this.outputKeyNodes = [
+            {
+                key: "ItemCollectionMetrics",
+                children: {
+                    children: [{ key: "ItemCollectionKey" }],
+                },
+            },
+        ];
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        const { marshallOptions, unmarshallOptions } = configuration.translateConfig || {};
+        const command = new client_dynamodb_1.TransactWriteItemsCommand(utils_1.marshallInput(this.input, this.inputKeyNodes, marshallOptions));
+        const handler = command.resolveMiddleware(clientStack, configuration, options);
+        return async () => {
+            const data = await handler(command);
+            return {
+                ...data,
+                output: utils_1.unmarshallOutput(data.output, this.outputKeyNodes, unmarshallOptions),
+            };
+        };
+    }
+}
+exports.TransactWriteCommand = TransactWriteCommand;

package/dist-cjs/commands/UpdateCommand.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateCommand = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const utils_1 = require("../commands/utils");
+class UpdateCommand extends smithy_client_1.Command {
+    constructor(input) {
+        super();
+        this.input = input;
+        this.inputKeyNodes = [
+            { key: "Key" },
+            {
+                key: "AttributeUpdates",
+                children: {
+                    children: [{ key: "Value" }],
+                },
+            },
+            {
+                key: "Expected",
+                children: {
+                    children: [{ key: "Value" }, { key: "AttributeValueList" }],
+                },
+            },
+            { key: "ExpressionAttributeValues" },
+        ];
+        this.outputKeyNodes = [
+            { key: "Attributes" },
+            { key: "ItemCollectionMetrics", children: [{ key: "ItemCollectionKey" }] },
+        ];
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        const { marshallOptions, unmarshallOptions } = configuration.translateConfig || {};
+        const command = new client_dynamodb_1.UpdateItemCommand(utils_1.marshallInput(this.input, this.inputKeyNodes, marshallOptions));
+        const handler = command.resolveMiddleware(clientStack, configuration, options);
+        return async () => {
+            const data = await handler(command);
+            return {
+                ...data,
+                output: utils_1.unmarshallOutput(data.output, this.outputKeyNodes, unmarshallOptions),
+            };
+        };
+    }
+}
+exports.UpdateCommand = UpdateCommand;

package/dist-cjs/commands/utils.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unmarshallOutput = exports.marshallInput = void 0;
+const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
+const processObj = (obj, processFunc, children) => {
+    if (obj) {
+        if (!children || (Array.isArray(children) && children.length === 0)) {
+            return processFunc(obj);
+        }
+        else {
+            if (Array.isArray(children)) {
+                return processKeysInObj(obj, processFunc, children);
+            }
+            else {
+                return processAllKeysInObj(obj, processFunc, children.children);
+            }
+        }
+    }
+    return undefined;
+};
+const processKeyInObj = (obj, processFunc, children) => {
+    if (Array.isArray(obj)) {
+        return obj.map((item) => processObj(item, processFunc, children));
+    }
+    return processObj(obj, processFunc, children);
+};
+const processKeysInObj = (obj, processFunc, keyNodes) => keyNodes.reduce((acc, { key, children }) => ({
+    ...acc,
+    [key]: processKeyInObj(acc[key], processFunc, children),
+}), obj);
+const processAllKeysInObj = (obj, processFunc, children) => Object.entries(obj).reduce((acc, [key, value]) => ({
+    ...acc,
+    [key]: processKeyInObj(value, processFunc, children),
+}), {});
+const marshallInput = (obj, keyNodes, options) => {
+    const marshallFunc = (toMarshall) => util_dynamodb_1.marshall(toMarshall, options);
+    return processKeysInObj(obj, marshallFunc, keyNodes);
+};
+exports.marshallInput = marshallInput;
+const unmarshallOutput = (obj, keyNodes, options) => {
+    const unmarshallFunc = (toMarshall) => util_dynamodb_1.unmarshall(toMarshall, options);
+    return processKeysInObj(obj, unmarshallFunc, keyNodes);
+};
+exports.unmarshallOutput = unmarshallOutput;

package/dist-cjs/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./commands/BatchExecuteStatementCommand"), exports);
+tslib_1.__exportStar(require("./commands/BatchGetCommand"), exports);
+tslib_1.__exportStar(require("./commands/BatchWriteCommand"), exports);
+tslib_1.__exportStar(require("./commands/DeleteCommand"), exports);
+tslib_1.__exportStar(require("./commands/ExecuteStatementCommand"), exports);
+tslib_1.__exportStar(require("./commands/ExecuteTransactionCommand"), exports);
+tslib_1.__exportStar(require("./commands/GetCommand"), exports);
+tslib_1.__exportStar(require("./commands/PutCommand"), exports);
+tslib_1.__exportStar(require("./commands/QueryCommand"), exports);
+tslib_1.__exportStar(require("./commands/ScanCommand"), exports);
+tslib_1.__exportStar(require("./commands/TransactGetCommand"), exports);
+tslib_1.__exportStar(require("./commands/TransactWriteCommand"), exports);
+tslib_1.__exportStar(require("./commands/UpdateCommand"), exports);
+tslib_1.__exportStar(require("./DynamoDBDocumentClient"), exports);
+tslib_1.__exportStar(require("./DynamoDBDocument"), exports);

package/dist-es/DynamoDBDocument.js

@@ -0,0 +1,208 @@
+import { __extends } from "tslib";
+import { BatchExecuteStatementCommand, } from "./commands/BatchExecuteStatementCommand";
+import { BatchGetCommand } from "./commands/BatchGetCommand";
+import { BatchWriteCommand } from "./commands/BatchWriteCommand";
+import { DeleteCommand } from "./commands/DeleteCommand";
+import { ExecuteStatementCommand, } from "./commands/ExecuteStatementCommand";
+import { ExecuteTransactionCommand, } from "./commands/ExecuteTransactionCommand";
+import { GetCommand } from "./commands/GetCommand";
+import { PutCommand } from "./commands/PutCommand";
+import { QueryCommand } from "./commands/QueryCommand";
+import { ScanCommand } from "./commands/ScanCommand";
+import { TransactGetCommand } from "./commands/TransactGetCommand";
+import { TransactWriteCommand, } from "./commands/TransactWriteCommand";
+import { UpdateCommand } from "./commands/UpdateCommand";
+import { DynamoDBDocumentClient } from "./DynamoDBDocumentClient";
+var DynamoDBDocument = (function (_super) {
+    __extends(DynamoDBDocument, _super);
+    function DynamoDBDocument() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DynamoDBDocument.from = function (client, translateConfig) {
+        return new DynamoDBDocument(client, translateConfig);
+    };
+    DynamoDBDocument.prototype.batchExecuteStatement = function (args, optionsOrCb, cb) {
+        var command = new BatchExecuteStatementCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    DynamoDBDocument.prototype.batchGet = function (args, optionsOrCb, cb) {
+        var command = new BatchGetCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    DynamoDBDocument.prototype.batchWrite = function (args, optionsOrCb, cb) {
+        var command = new BatchWriteCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    DynamoDBDocument.prototype.delete = function (args, optionsOrCb, cb) {
+        var command = new DeleteCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    DynamoDBDocument.prototype.executeStatement = function (args, optionsOrCb, cb) {
+        var command = new ExecuteStatementCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    DynamoDBDocument.prototype.executeTransaction = function (args, optionsOrCb, cb) {
+        var command = new ExecuteTransactionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    DynamoDBDocument.prototype.get = function (args, optionsOrCb, cb) {
+        var command = new GetCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    DynamoDBDocument.prototype.put = function (args, optionsOrCb, cb) {
+        var command = new PutCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    DynamoDBDocument.prototype.query = function (args, optionsOrCb, cb) {
+        var command = new QueryCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    DynamoDBDocument.prototype.scan = function (args, optionsOrCb, cb) {
+        var command = new ScanCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    DynamoDBDocument.prototype.transactGet = function (args, optionsOrCb, cb) {
+        var command = new TransactGetCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    DynamoDBDocument.prototype.transactWrite = function (args, optionsOrCb, cb) {
+        var command = new TransactWriteCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    DynamoDBDocument.prototype.update = function (args, optionsOrCb, cb) {
+        var command = new UpdateCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    return DynamoDBDocument;
+}(DynamoDBDocumentClient));
+export { DynamoDBDocument };

package/dist-es/DynamoDBDocumentClient.js

@@ -0,0 +1,19 @@
+import { __extends } from "tslib";
+import { Client as __Client } from "@aws-sdk/smithy-client";
+var DynamoDBDocumentClient = (function (_super) {
+    __extends(DynamoDBDocumentClient, _super);
+    function DynamoDBDocumentClient(client, translateConfig) {
+        var _this = _super.call(this, client.config) || this;
+        _this.config = client.config;
+        _this.config.translateConfig = translateConfig;
+        _this.middlewareStack = client.middlewareStack;
+        return _this;
+    }
+    DynamoDBDocumentClient.from = function (client, translateConfig) {
+        return new DynamoDBDocumentClient(client, translateConfig);
+    };
+    DynamoDBDocumentClient.prototype.destroy = function () {
+    };
+    return DynamoDBDocumentClient;
+}(__Client));
+export { DynamoDBDocumentClient };

package/dist-es/commands/BatchExecuteStatementCommand.js

@@ -0,0 +1,33 @@
+import { __assign, __awaiter, __extends, __generator } from "tslib";
+import { BatchExecuteStatementCommand as __BatchExecuteStatementCommand, } from "@aws-sdk/client-dynamodb";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { marshallInput, unmarshallOutput } from "../commands/utils";
+var BatchExecuteStatementCommand = (function (_super) {
+    __extends(BatchExecuteStatementCommand, _super);
+    function BatchExecuteStatementCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        _this.inputKeyNodes = [{ key: "Statements", children: [{ key: "Parameters" }] }];
+        _this.outputKeyNodes = [{ key: "Responses", children: [{ key: "Item" }] }];
+        return _this;
+    }
+    BatchExecuteStatementCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        var _this = this;
+        var _a = configuration.translateConfig || {}, marshallOptions = _a.marshallOptions, unmarshallOptions = _a.unmarshallOptions;
+        var command = new __BatchExecuteStatementCommand(marshallInput(this.input, this.inputKeyNodes, marshallOptions));
+        var handler = command.resolveMiddleware(clientStack, configuration, options);
+        return function () { return __awaiter(_this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, handler(command)];
+                    case 1:
+                        data = _a.sent();
+                        return [2, __assign(__assign({}, data), { output: unmarshallOutput(data.output, this.outputKeyNodes, unmarshallOptions) })];
+                }
+            });
+        }); };
+    };
+    return BatchExecuteStatementCommand;
+}($Command));
+export { BatchExecuteStatementCommand };

package/dist-es/commands/BatchGetCommand.js

@@ -0,0 +1,48 @@
+import { __assign, __awaiter, __extends, __generator } from "tslib";
+import { BatchGetItemCommand as __BatchGetItemCommand, } from "@aws-sdk/client-dynamodb";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { marshallInput, unmarshallOutput } from "../commands/utils";
+var BatchGetCommand = (function (_super) {
+    __extends(BatchGetCommand, _super);
+    function BatchGetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        _this.inputKeyNodes = [
+            {
+                key: "RequestItems",
+                children: {
+                    children: [{ key: "Keys" }],
+                },
+            },
+        ];
+        _this.outputKeyNodes = [
+            { key: "Responses", children: {} },
+            {
+                key: "UnprocessedKeys",
+                children: {
+                    children: [{ key: "Keys" }],
+                },
+            },
+        ];
+        return _this;
+    }
+    BatchGetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        var _this = this;
+        var _a = configuration.translateConfig || {}, marshallOptions = _a.marshallOptions, unmarshallOptions = _a.unmarshallOptions;
+        var command = new __BatchGetItemCommand(marshallInput(this.input, this.inputKeyNodes, marshallOptions));
+        var handler = command.resolveMiddleware(clientStack, configuration, options);
+        return function () { return __awaiter(_this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, handler(command)];
+                    case 1:
+                        data = _a.sent();
+                        return [2, __assign(__assign({}, data), { output: unmarshallOutput(data.output, this.outputKeyNodes, unmarshallOptions) })];
+                }
+            });
+        }); };
+    };
+    return BatchGetCommand;
+}($Command));
+export { BatchGetCommand };

package/dist-es/commands/BatchWriteCommand.js

@@ -0,0 +1,59 @@
+import { __assign, __awaiter, __extends, __generator } from "tslib";
+import { BatchWriteItemCommand as __BatchWriteItemCommand, } from "@aws-sdk/client-dynamodb";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { marshallInput, unmarshallOutput } from "../commands/utils";
+var BatchWriteCommand = (function (_super) {
+    __extends(BatchWriteCommand, _super);
+    function BatchWriteCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        _this.inputKeyNodes = [
+            {
+                key: "RequestItems",
+                children: {
+                    children: [
+                        { key: "PutRequest", children: [{ key: "Item" }] },
+                        { key: "DeleteRequest", children: [{ key: "Key" }] },
+                    ],
+                },
+            },
+        ];
+        _this.outputKeyNodes = [
+            {
+                key: "UnprocessedItems",
+                children: {
+                    children: [
+                        { key: "PutRequest", children: [{ key: "Item" }] },
+                        { key: "DeleteRequest", children: [{ key: "Key" }] },
+                    ],
+                },
+            },
+            {
+                key: "ItemCollectionMetrics",
+                children: {
+                    children: [{ key: "ItemCollectionKey" }],
+                },
+            },
+        ];
+        return _this;
+    }
+    BatchWriteCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        var _this = this;
+        var _a = configuration.translateConfig || {}, marshallOptions = _a.marshallOptions, unmarshallOptions = _a.unmarshallOptions;
+        var command = new __BatchWriteItemCommand(marshallInput(this.input, this.inputKeyNodes, marshallOptions));
+        var handler = command.resolveMiddleware(clientStack, configuration, options);
+        return function () { return __awaiter(_this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, handler(command)];
+                    case 1:
+                        data = _a.sent();
+                        return [2, __assign(__assign({}, data), { output: unmarshallOutput(data.output, this.outputKeyNodes, unmarshallOptions) })];
+                }
+            });
+        }); };
+    };
+    return BatchWriteCommand;
+}($Command));
+export { BatchWriteCommand };

package/dist-es/commands/DeleteCommand.js

@@ -0,0 +1,45 @@
+import { __assign, __awaiter, __extends, __generator } from "tslib";
+import { DeleteItemCommand as __DeleteItemCommand, } from "@aws-sdk/client-dynamodb";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { marshallInput, unmarshallOutput } from "../commands/utils";
+var DeleteCommand = (function (_super) {
+    __extends(DeleteCommand, _super);
+    function DeleteCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        _this.inputKeyNodes = [
+            { key: "Key" },
+            {
+                key: "Expected",
+                children: {
+                    children: [{ key: "Value" }, { key: "AttributeValueList" }],
+                },
+            },
+            { key: "ExpressionAttributeValues" },
+        ];
+        _this.outputKeyNodes = [
+            { key: "Attributes" },
+            { key: "ItemCollectionMetrics", children: [{ key: "ItemCollectionKey" }] },
+        ];
+        return _this;
+    }
+    DeleteCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        var _this = this;
+        var _a = configuration.translateConfig || {}, marshallOptions = _a.marshallOptions, unmarshallOptions = _a.unmarshallOptions;
+        var command = new __DeleteItemCommand(marshallInput(this.input, this.inputKeyNodes, marshallOptions));
+        var handler = command.resolveMiddleware(clientStack, configuration, options);
+        return function () { return __awaiter(_this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, handler(command)];
+                    case 1:
+                        data = _a.sent();
+                        return [2, __assign(__assign({}, data), { output: unmarshallOutput(data.output, this.outputKeyNodes, unmarshallOptions) })];
+                }
+            });
+        }); };
+    };
+    return DeleteCommand;
+}($Command));
+export { DeleteCommand };

package/dist-es/commands/ExecuteStatementCommand.js

@@ -0,0 +1,33 @@
+import { __assign, __awaiter, __extends, __generator } from "tslib";
+import { ExecuteStatementCommand as __ExecuteStatementCommand, } from "@aws-sdk/client-dynamodb";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { marshallInput, unmarshallOutput } from "../commands/utils";
+var ExecuteStatementCommand = (function (_super) {
+    __extends(ExecuteStatementCommand, _super);
+    function ExecuteStatementCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        _this.inputKeyNodes = [{ key: "Parameters" }];
+        _this.outputKeyNodes = [{ key: "Items" }];
+        return _this;
+    }
+    ExecuteStatementCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        var _this = this;
+        var _a = configuration.translateConfig || {}, marshallOptions = _a.marshallOptions, unmarshallOptions = _a.unmarshallOptions;
+        var command = new __ExecuteStatementCommand(marshallInput(this.input, this.inputKeyNodes, marshallOptions));
+        var handler = command.resolveMiddleware(clientStack, configuration, options);
+        return function () { return __awaiter(_this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, handler(command)];
+                    case 1:
+                        data = _a.sent();
+                        return [2, __assign(__assign({}, data), { output: unmarshallOutput(data.output, this.outputKeyNodes, unmarshallOptions) })];
+                }
+            });
+        }); };
+    };
+    return ExecuteStatementCommand;
+}($Command));
+export { ExecuteStatementCommand };

package/dist-es/commands/ExecuteTransactionCommand.js

@@ -0,0 +1,33 @@
+import { __assign, __awaiter, __extends, __generator } from "tslib";
+import { ExecuteTransactionCommand as __ExecuteTransactionCommand, } from "@aws-sdk/client-dynamodb";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { marshallInput, unmarshallOutput } from "../commands/utils";
+var ExecuteTransactionCommand = (function (_super) {
+    __extends(ExecuteTransactionCommand, _super);
+    function ExecuteTransactionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        _this.inputKeyNodes = [{ key: "TransactStatements", children: [{ key: "Parameters" }] }];
+        _this.outputKeyNodes = [{ key: "Responses", children: [{ key: "Item" }] }];
+        return _this;
+    }
+    ExecuteTransactionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        var _this = this;
+        var _a = configuration.translateConfig || {}, marshallOptions = _a.marshallOptions, unmarshallOptions = _a.unmarshallOptions;
+        var command = new __ExecuteTransactionCommand(marshallInput(this.input, this.inputKeyNodes, marshallOptions));
+        var handler = command.resolveMiddleware(clientStack, configuration, options);
+        return function () { return __awaiter(_this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, handler(command)];
+                    case 1:
+                        data = _a.sent();
+                        return [2, __assign(__assign({}, data), { output: unmarshallOutput(data.output, this.outputKeyNodes, unmarshallOptions) })];
+                }
+            });
+        }); };
+    };
+    return ExecuteTransactionCommand;
+}($Command));
+export { ExecuteTransactionCommand };