@aws-sdk/lib-dynamodb 3.185.0 → 3.186.0

package/dist-es/commands/ExecuteTransactionCommand.js

@@ -1,18 +1,26 @@
+import { __awaiter, __extends, __generator } from "tslib";
 import { ExecuteTransactionCommand as __ExecuteTransactionCommand, } from "@aws-sdk/client-dynamodb";
 import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
-export class ExecuteTransactionCommand extends DynamoDBDocumentClientCommand {
-    constructor(input) {
-        super();
-        this.input = input;
-        this.inputKeyNodes = [{ key: "TransactStatements", children: [{ key: "Parameters" }] }];
-        this.outputKeyNodes = [{ key: "Responses", children: [{ key: "Item" }] }];
-        this.clientCommand = new __ExecuteTransactionCommand(this.input);
-        this.middlewareStack = this.clientCommand.middlewareStack;
+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" }] }];
+        _this.clientCommand = new __ExecuteTransactionCommand(_this.input);
+        _this.middlewareStack = _this.clientCommand.middlewareStack;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ExecuteTransactionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        var _this = this;
         this.addMarshallingMiddleware(configuration);
-        const stack = clientStack.concat(this.middlewareStack);
-        const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
-        return async () => handler(this.clientCommand);
-    }
-}
+        var stack = clientStack.concat(this.middlewareStack);
+        var handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+        return function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2, handler(this.clientCommand)];
+        }); }); };
+    };
+    return ExecuteTransactionCommand;
+}(DynamoDBDocumentClientCommand));
+export { ExecuteTransactionCommand };

package/dist-es/commands/GetCommand.js

@@ -1,18 +1,26 @@
+import { __awaiter, __extends, __generator } from "tslib";
 import { GetItemCommand as __GetItemCommand, } from "@aws-sdk/client-dynamodb";
 import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
-export class GetCommand extends DynamoDBDocumentClientCommand {
-    constructor(input) {
-        super();
-        this.input = input;
-        this.inputKeyNodes = [{ key: "Key" }];
-        this.outputKeyNodes = [{ key: "Item" }];
-        this.clientCommand = new __GetItemCommand(this.input);
-        this.middlewareStack = this.clientCommand.middlewareStack;
+var GetCommand = (function (_super) {
+    __extends(GetCommand, _super);
+    function GetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        _this.inputKeyNodes = [{ key: "Key" }];
+        _this.outputKeyNodes = [{ key: "Item" }];
+        _this.clientCommand = new __GetItemCommand(_this.input);
+        _this.middlewareStack = _this.clientCommand.middlewareStack;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        var _this = this;
         this.addMarshallingMiddleware(configuration);
-        const stack = clientStack.concat(this.middlewareStack);
-        const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
-        return async () => handler(this.clientCommand);
-    }
-}
+        var stack = clientStack.concat(this.middlewareStack);
+        var handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+        return function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2, handler(this.clientCommand)];
+        }); }); };
+    };
+    return GetCommand;
+}(DynamoDBDocumentClientCommand));
+export { GetCommand };

package/dist-es/commands/PutCommand.js

@@ -1,10 +1,12 @@
+import { __awaiter, __extends, __generator } from "tslib";
 import { PutItemCommand as __PutItemCommand, } from "@aws-sdk/client-dynamodb";
 import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
-export class PutCommand extends DynamoDBDocumentClientCommand {
-    constructor(input) {
-        super();
-        this.input = input;
-        this.inputKeyNodes = [
+var PutCommand = (function (_super) {
+    __extends(PutCommand, _super);
+    function PutCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        _this.inputKeyNodes = [
             { key: "Item" },
             {
                 key: "Expected",
@@ -14,17 +16,23 @@ export class PutCommand extends DynamoDBDocumentClientCommand {
             },
             { key: "ExpressionAttributeValues" },
         ];
-        this.outputKeyNodes = [
+        _this.outputKeyNodes = [
             { key: "Attributes" },
             { key: "ItemCollectionMetrics", children: [{ key: "ItemCollectionKey" }] },
         ];
-        this.clientCommand = new __PutItemCommand(this.input);
-        this.middlewareStack = this.clientCommand.middlewareStack;
+        _this.clientCommand = new __PutItemCommand(_this.input);
+        _this.middlewareStack = _this.clientCommand.middlewareStack;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    PutCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        var _this = this;
         this.addMarshallingMiddleware(configuration);
-        const stack = clientStack.concat(this.middlewareStack);
-        const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
-        return async () => handler(this.clientCommand);
-    }
-}
+        var stack = clientStack.concat(this.middlewareStack);
+        var handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+        return function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2, handler(this.clientCommand)];
+        }); }); };
+    };
+    return PutCommand;
+}(DynamoDBDocumentClientCommand));
+export { PutCommand };

package/dist-es/commands/QueryCommand.js

@@ -1,10 +1,12 @@
+import { __awaiter, __extends, __generator } from "tslib";
 import { QueryCommand as __QueryCommand, } from "@aws-sdk/client-dynamodb";
 import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
-export class QueryCommand extends DynamoDBDocumentClientCommand {
-    constructor(input) {
-        super();
-        this.input = input;
-        this.inputKeyNodes = [
+var QueryCommand = (function (_super) {
+    __extends(QueryCommand, _super);
+    function QueryCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        _this.inputKeyNodes = [
             {
                 key: "KeyConditions",
                 children: {
@@ -20,14 +22,20 @@ export class QueryCommand extends DynamoDBDocumentClientCommand {
             { key: "ExclusiveStartKey" },
             { key: "ExpressionAttributeValues" },
         ];
-        this.outputKeyNodes = [{ key: "Items" }, { key: "LastEvaluatedKey" }];
-        this.clientCommand = new __QueryCommand(this.input);
-        this.middlewareStack = this.clientCommand.middlewareStack;
+        _this.outputKeyNodes = [{ key: "Items" }, { key: "LastEvaluatedKey" }];
+        _this.clientCommand = new __QueryCommand(_this.input);
+        _this.middlewareStack = _this.clientCommand.middlewareStack;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    QueryCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        var _this = this;
         this.addMarshallingMiddleware(configuration);
-        const stack = clientStack.concat(this.middlewareStack);
-        const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
-        return async () => handler(this.clientCommand);
-    }
-}
+        var stack = clientStack.concat(this.middlewareStack);
+        var handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+        return function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2, handler(this.clientCommand)];
+        }); }); };
+    };
+    return QueryCommand;
+}(DynamoDBDocumentClientCommand));
+export { QueryCommand };

package/dist-es/commands/ScanCommand.js

@@ -1,10 +1,12 @@
+import { __awaiter, __extends, __generator } from "tslib";
 import { ScanCommand as __ScanCommand, } from "@aws-sdk/client-dynamodb";
 import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
-export class ScanCommand extends DynamoDBDocumentClientCommand {
-    constructor(input) {
-        super();
-        this.input = input;
-        this.inputKeyNodes = [
+var ScanCommand = (function (_super) {
+    __extends(ScanCommand, _super);
+    function ScanCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        _this.inputKeyNodes = [
             {
                 key: "ScanFilter",
                 children: {
@@ -14,14 +16,20 @@ export class ScanCommand extends DynamoDBDocumentClientCommand {
             { key: "ExclusiveStartKey" },
             { key: "ExpressionAttributeValues" },
         ];
-        this.outputKeyNodes = [{ key: "Items" }, { key: "LastEvaluatedKey" }];
-        this.clientCommand = new __ScanCommand(this.input);
-        this.middlewareStack = this.clientCommand.middlewareStack;
+        _this.outputKeyNodes = [{ key: "Items" }, { key: "LastEvaluatedKey" }];
+        _this.clientCommand = new __ScanCommand(_this.input);
+        _this.middlewareStack = _this.clientCommand.middlewareStack;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ScanCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        var _this = this;
         this.addMarshallingMiddleware(configuration);
-        const stack = clientStack.concat(this.middlewareStack);
-        const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
-        return async () => handler(this.clientCommand);
-    }
-}
+        var stack = clientStack.concat(this.middlewareStack);
+        var handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+        return function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2, handler(this.clientCommand)];
+        }); }); };
+    };
+    return ScanCommand;
+}(DynamoDBDocumentClientCommand));
+export { ScanCommand };

package/dist-es/commands/TransactGetCommand.js

@@ -1,18 +1,26 @@
+import { __awaiter, __extends, __generator } from "tslib";
 import { TransactGetItemsCommand as __TransactGetItemsCommand, } from "@aws-sdk/client-dynamodb";
 import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
-export class TransactGetCommand extends DynamoDBDocumentClientCommand {
-    constructor(input) {
-        super();
-        this.input = input;
-        this.inputKeyNodes = [{ key: "TransactItems", children: [{ key: "Get", children: [{ key: "Key" }] }] }];
-        this.outputKeyNodes = [{ key: "Responses", children: [{ key: "Item" }] }];
-        this.clientCommand = new __TransactGetItemsCommand(this.input);
-        this.middlewareStack = this.clientCommand.middlewareStack;
+var TransactGetCommand = (function (_super) {
+    __extends(TransactGetCommand, _super);
+    function TransactGetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        _this.inputKeyNodes = [{ key: "TransactItems", children: [{ key: "Get", children: [{ key: "Key" }] }] }];
+        _this.outputKeyNodes = [{ key: "Responses", children: [{ key: "Item" }] }];
+        _this.clientCommand = new __TransactGetItemsCommand(_this.input);
+        _this.middlewareStack = _this.clientCommand.middlewareStack;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    TransactGetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        var _this = this;
         this.addMarshallingMiddleware(configuration);
-        const stack = clientStack.concat(this.middlewareStack);
-        const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
-        return async () => handler(this.clientCommand);
-    }
-}
+        var stack = clientStack.concat(this.middlewareStack);
+        var handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+        return function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2, handler(this.clientCommand)];
+        }); }); };
+    };
+    return TransactGetCommand;
+}(DynamoDBDocumentClientCommand));
+export { TransactGetCommand };

package/dist-es/commands/TransactWriteCommand.js

@@ -1,10 +1,12 @@
+import { __awaiter, __extends, __generator } from "tslib";
 import { TransactWriteItemsCommand as __TransactWriteItemsCommand, } from "@aws-sdk/client-dynamodb";
 import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
-export class TransactWriteCommand extends DynamoDBDocumentClientCommand {
-    constructor(input) {
-        super();
-        this.input = input;
-        this.inputKeyNodes = [
+var TransactWriteCommand = (function (_super) {
+    __extends(TransactWriteCommand, _super);
+    function TransactWriteCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        _this.inputKeyNodes = [
             {
                 key: "TransactItems",
                 children: [
@@ -15,7 +17,7 @@ export class TransactWriteCommand extends DynamoDBDocumentClientCommand {
                 ],
             },
         ];
-        this.outputKeyNodes = [
+        _this.outputKeyNodes = [
             {
                 key: "ItemCollectionMetrics",
                 children: {
@@ -23,13 +25,19 @@ export class TransactWriteCommand extends DynamoDBDocumentClientCommand {
                 },
             },
         ];
-        this.clientCommand = new __TransactWriteItemsCommand(this.input);
-        this.middlewareStack = this.clientCommand.middlewareStack;
+        _this.clientCommand = new __TransactWriteItemsCommand(_this.input);
+        _this.middlewareStack = _this.clientCommand.middlewareStack;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    TransactWriteCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        var _this = this;
         this.addMarshallingMiddleware(configuration);
-        const stack = clientStack.concat(this.middlewareStack);
-        const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
-        return async () => handler(this.clientCommand);
-    }
-}
+        var stack = clientStack.concat(this.middlewareStack);
+        var handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+        return function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2, handler(this.clientCommand)];
+        }); }); };
+    };
+    return TransactWriteCommand;
+}(DynamoDBDocumentClientCommand));
+export { TransactWriteCommand };

package/dist-es/commands/UpdateCommand.js

@@ -1,10 +1,12 @@
+import { __awaiter, __extends, __generator } from "tslib";
 import { UpdateItemCommand as __UpdateItemCommand, } from "@aws-sdk/client-dynamodb";
 import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
-export class UpdateCommand extends DynamoDBDocumentClientCommand {
-    constructor(input) {
-        super();
-        this.input = input;
-        this.inputKeyNodes = [
+var UpdateCommand = (function (_super) {
+    __extends(UpdateCommand, _super);
+    function UpdateCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        _this.inputKeyNodes = [
             { key: "Key" },
             {
                 key: "AttributeUpdates",
@@ -20,17 +22,23 @@ export class UpdateCommand extends DynamoDBDocumentClientCommand {
             },
             { key: "ExpressionAttributeValues" },
         ];
-        this.outputKeyNodes = [
+        _this.outputKeyNodes = [
             { key: "Attributes" },
             { key: "ItemCollectionMetrics", children: [{ key: "ItemCollectionKey" }] },
         ];
-        this.clientCommand = new __UpdateItemCommand(this.input);
-        this.middlewareStack = this.clientCommand.middlewareStack;
+        _this.clientCommand = new __UpdateItemCommand(_this.input);
+        _this.middlewareStack = _this.clientCommand.middlewareStack;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        var _this = this;
         this.addMarshallingMiddleware(configuration);
-        const stack = clientStack.concat(this.middlewareStack);
-        const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
-        return async () => handler(this.clientCommand);
-    }
-}
+        var stack = clientStack.concat(this.middlewareStack);
+        var handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+        return function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2, handler(this.clientCommand)];
+        }); }); };
+    };
+    return UpdateCommand;
+}(DynamoDBDocumentClientCommand));
+export { UpdateCommand };

package/dist-es/commands/utils.js

@@ -1,5 +1,6 @@
+import { __assign, __read } from "tslib";
 import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";
-const processObj = (obj, processFunc, children) => {
+var processObj = function (obj, processFunc, children) {
     if (obj !== undefined) {
         if (!children || (Array.isArray(children) && children.length === 0)) {
             return processFunc(obj);
@@ -15,25 +16,31 @@ const processObj = (obj, processFunc, children) => {
     }
     return undefined;
 };
-const processKeyInObj = (obj, processFunc, children) => {
+var processKeyInObj = function (obj, processFunc, children) {
     if (Array.isArray(obj)) {
-        return obj.map((item) => processObj(item, processFunc, children));
+        return obj.map(function (item) { return 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),
-}), {});
-export const marshallInput = (obj, keyNodes, options) => {
-    const marshallFunc = (toMarshall) => marshall(toMarshall, options);
+var processKeysInObj = function (obj, processFunc, keyNodes) {
+    return keyNodes.reduce(function (acc, _a) {
+        var _b;
+        var key = _a.key, children = _a.children;
+        return (__assign(__assign({}, acc), (_b = {}, _b[key] = processKeyInObj(acc[key], processFunc, children), _b)));
+    }, obj);
+};
+var processAllKeysInObj = function (obj, processFunc, children) {
+    return Object.entries(obj).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
+        return (__assign(__assign({}, acc), (_b = {}, _b[key] = processKeyInObj(value, processFunc, children), _b)));
+    }, {});
+};
+export var marshallInput = function (obj, keyNodes, options) {
+    var marshallFunc = function (toMarshall) { return marshall(toMarshall, options); };
     return processKeysInObj(obj, marshallFunc, keyNodes);
 };
-export const unmarshallOutput = (obj, keyNodes, options) => {
-    const unmarshallFunc = (toMarshall) => unmarshall(toMarshall, options);
+export var unmarshallOutput = function (obj, keyNodes, options) {
+    var unmarshallFunc = function (toMarshall) { return unmarshall(toMarshall, options); };
     return processKeysInObj(obj, unmarshallFunc, keyNodes);
 };

package/dist-es/pagination/QueryPaginator.js

@@ -1,31 +1,74 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
 import { QueryCommand } from "../commands/QueryCommand";
 import { DynamoDBDocument } from "../DynamoDBDocument";
 import { DynamoDBDocumentClient } from "../DynamoDBDocumentClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new QueryCommand(input), ...args);
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new QueryCommand(input)], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.query(input, ...args);
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.query.apply(client, __spreadArray([input], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
 };
-export async function* paginateQuery(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.ExclusiveStartKey = token;
-        input["Limit"] = config.pageSize;
-        if (config.client instanceof DynamoDBDocument) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof DynamoDBDocumentClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected DynamoDBDocument | DynamoDBDocumentClient");
-        }
-        yield page;
-        token = page.LastEvaluatedKey;
-        hasNext = !!token;
+export function paginateQuery(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
     }
-    return undefined;
+    return __asyncGenerator(this, arguments, function paginateQuery_1() {
+        var token, hasNext, page;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.ExclusiveStartKey = token;
+                    input["Limit"] = config.pageSize;
+                    if (!(config.client instanceof DynamoDBDocument)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof DynamoDBDocumentClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected DynamoDBDocument | DynamoDBDocumentClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    token = page.LastEvaluatedKey;
+                    hasNext = !!token;
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
 }

package/dist-es/pagination/ScanPaginator.js

@@ -1,31 +1,74 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
 import { ScanCommand } from "../commands/ScanCommand";
 import { DynamoDBDocument } from "../DynamoDBDocument";
 import { DynamoDBDocumentClient } from "../DynamoDBDocumentClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ScanCommand(input), ...args);
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new ScanCommand(input)], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.scan(input, ...args);
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.scan.apply(client, __spreadArray([input], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
 };
-export async function* paginateScan(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.ExclusiveStartKey = token;
-        input["Limit"] = config.pageSize;
-        if (config.client instanceof DynamoDBDocument) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof DynamoDBDocumentClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected DynamoDBDocument | DynamoDBDocumentClient");
-        }
-        yield page;
-        token = page.LastEvaluatedKey;
-        hasNext = !!token;
+export function paginateScan(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
     }
-    return undefined;
+    return __asyncGenerator(this, arguments, function paginateScan_1() {
+        var token, hasNext, page;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.ExclusiveStartKey = token;
+                    input["Limit"] = config.pageSize;
+                    if (!(config.client instanceof DynamoDBDocument)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof DynamoDBDocumentClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected DynamoDBDocument | DynamoDBDocumentClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    token = page.LastEvaluatedKey;
+                    hasNext = !!token;
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
 }