@aws-sdk/lib-dynamodb 3.181.0 → 3.185.0

package/dist-es/commands/ExecuteTransactionCommand.js

@@ -1,26 +1,18 @@
-import { __awaiter, __extends, __generator } from "tslib";
 import { ExecuteTransactionCommand as __ExecuteTransactionCommand, } from "@aws-sdk/client-dynamodb";
 import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
-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;
+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;
     }
-    ExecuteTransactionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
-        var _this = this;
+    resolveMiddleware(clientStack, configuration, options) {
         this.addMarshallingMiddleware(configuration);
-        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 };
+        const stack = clientStack.concat(this.middlewareStack);
+        const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+        return async () => handler(this.clientCommand);
+    }
+}

package/dist-es/commands/GetCommand.js

@@ -1,26 +1,18 @@
-import { __awaiter, __extends, __generator } from "tslib";
 import { GetItemCommand as __GetItemCommand, } from "@aws-sdk/client-dynamodb";
 import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
-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;
+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;
     }
-    GetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
-        var _this = this;
+    resolveMiddleware(clientStack, configuration, options) {
         this.addMarshallingMiddleware(configuration);
-        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 };
+        const stack = clientStack.concat(this.middlewareStack);
+        const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+        return async () => handler(this.clientCommand);
+    }
+}

package/dist-es/commands/PutCommand.js

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

package/dist-es/commands/QueryCommand.js

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

package/dist-es/commands/ScanCommand.js

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

package/dist-es/commands/TransactGetCommand.js

@@ -1,26 +1,18 @@
-import { __awaiter, __extends, __generator } from "tslib";
 import { TransactGetItemsCommand as __TransactGetItemsCommand, } from "@aws-sdk/client-dynamodb";
 import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
-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;
+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;
     }
-    TransactGetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
-        var _this = this;
+    resolveMiddleware(clientStack, configuration, options) {
         this.addMarshallingMiddleware(configuration);
-        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 };
+        const stack = clientStack.concat(this.middlewareStack);
+        const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+        return async () => handler(this.clientCommand);
+    }
+}

package/dist-es/commands/TransactWriteCommand.js

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

package/dist-es/commands/UpdateCommand.js

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

package/dist-es/commands/utils.js

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

package/dist-es/pagination/QueryPaginator.js

@@ -1,74 +1,31 @@
-import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
 import { QueryCommand } from "../commands/QueryCommand";
 import { DynamoDBDocument } from "../DynamoDBDocument";
 import { DynamoDBDocumentClient } from "../DynamoDBDocumentClient";
-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 makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new QueryCommand(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()];
-            }
-        });
-    });
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.query(input, ...args);
 };
-export function paginateQuery(config, input) {
-    var additionalArguments = [];
-    for (var _i = 2; _i < arguments.length; _i++) {
-        additionalArguments[_i - 2] = arguments[_i];
+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;
     }
-    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()];
-            }
-        });
-    });
+    return undefined;
 }

package/dist-es/pagination/ScanPaginator.js

@@ -1,74 +1,31 @@
-import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
 import { ScanCommand } from "../commands/ScanCommand";
 import { DynamoDBDocument } from "../DynamoDBDocument";
 import { DynamoDBDocumentClient } from "../DynamoDBDocumentClient";
-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 makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ScanCommand(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()];
-            }
-        });
-    });
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.scan(input, ...args);
 };
-export function paginateScan(config, input) {
-    var additionalArguments = [];
-    for (var _i = 2; _i < arguments.length; _i++) {
-        additionalArguments[_i - 2] = arguments[_i];
+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;
     }
-    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()];
-            }
-        });
-    });
+    return undefined;
 }