@webda/aws 2.0.0-beta.3 → 2.1.0

package/lib/services/dynamodb.js

@@ -1,33 +1,19 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DynamoStore = exports.DynamoStoreParameters = void 0;
-const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
-const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
-const core_1 = require("@webda/core");
-const _1 = require(".");
+import { ConditionalCheckFailedException, DynamoDB, DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocument } from "@aws-sdk/lib-dynamodb";
+import { CoreModel, Store, StoreNotFoundError, StoreParameters, UpdateConditionFailError, WebdaError, WebdaQL } from "@webda/core";
+import { AWSServiceParameters } from "./index.js";
 /**
  * Define DynamoDB parameters
  */
-class DynamoStoreParameters extends (0, _1.AWSServiceParameters)(core_1.StoreParameters) {
+export class DynamoStoreParameters extends AWSServiceParameters(StoreParameters) {
     constructor(params, service) {
-        var _a;
         super(params, service);
         if (this.table === undefined) {
-            throw new core_1.WebdaError("DYNAMODB_TABLE_PARAMETER_REQUIRED", "Need to define a table at least");
+            throw new WebdaError("DYNAMODB_TABLE_PARAMETER_REQUIRED", "Need to define a table at least");
         }
-        (_a = this.globalIndexes) !== null && _a !== void 0 ? _a : (this.globalIndexes = {});
+        this.globalIndexes ?? (this.globalIndexes = {});
     }
 }
-exports.DynamoStoreParameters = DynamoStoreParameters;
 /**
  * DynamoStore handles the DynamoDB
  *
@@ -39,7 +25,7 @@ exports.DynamoStoreParameters = DynamoStoreParameters;
  *
  * @WebdaModda
  */
-class DynamoStore extends core_1.Store {
+export default class DynamoStore extends Store {
     /**
      * Load the parameters
      *
@@ -53,7 +39,7 @@ class DynamoStore extends core_1.Store {
      */
     resolve() {
         super.resolve();
-        this._client = lib_dynamodb_1.DynamoDBDocument.from(new client_dynamodb_1.DynamoDBClient(this.parameters), {
+        this._client = DynamoDBDocument.from(new DynamoDBClient(this.parameters), {
             marshallOptions: {
                 removeUndefinedValues: true
             }
@@ -67,54 +53,48 @@ class DynamoStore extends core_1.Store {
      * @param source
      * @param target
      */
-    static copyTable(output, source, target) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let db = new client_dynamodb_1.DynamoDB({});
-            let ExclusiveStartKey;
-            let props = yield db.describeTable({
-                TableName: source
+    static async copyTable(output, source, target) {
+        let db = new DynamoDB({});
+        let ExclusiveStartKey;
+        let props = await db.describeTable({
+            TableName: source
+        });
+        output.startProgress("copyTable", props.Table.ItemCount, `Copying ${source} to ${target}`);
+        do {
+            let info = await db.scan({
+                TableName: source,
+                ExclusiveStartKey
             });
-            output.startProgress("copyTable", props.Table.ItemCount, `Copying ${source} to ${target}`);
             do {
-                let info = yield db.scan({
-                    TableName: source,
-                    ExclusiveStartKey
-                });
-                do {
-                    let items = [];
-                    while (info.Items.length && items.length < 25) {
-                        items.push(info.Items.shift());
-                    }
-                    if (!items.length) {
-                        break;
-                    }
-                    let params = {
-                        RequestItems: {}
-                    };
-                    params.RequestItems[target] = items.map(Item => ({ PutRequest: { Item } }));
-                    yield db.batchWriteItem(params);
-                    output.incrementProgress(items.length, "copyTable");
-                } while (true);
-                ExclusiveStartKey = info.LastEvaluatedKey;
-            } while (ExclusiveStartKey);
-        });
+                let items = [];
+                while (info.Items.length && items.length < 25) {
+                    items.push(info.Items.shift());
+                }
+                if (!items.length) {
+                    break;
+                }
+                let params = {
+                    RequestItems: {}
+                };
+                params.RequestItems[target] = items.map(Item => ({ PutRequest: { Item } }));
+                await db.batchWriteItem(params);
+                output.incrementProgress(items.length, "copyTable");
+            } while (true);
+            ExclusiveStartKey = info.LastEvaluatedKey;
+        } while (ExclusiveStartKey);
     }
     /**
      * @inheritdoc
      */
-    exists(uid) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Should use find + limit 1
-            return (yield this._get(uid)) !== undefined;
-        });
+    async exists(uid) {
+        // Should use find + limit 1
+        return (await this._get(uid)) !== undefined;
     }
     /**
      * @inheritdoc
      */
-    _save(object, uid = object.uuid) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._update(object, uid);
-        });
+    async _save(object, uid = object.uuid) {
+        return this._update(object, uid);
     }
     /**
      * @override
@@ -122,160 +102,158 @@ class DynamoStore extends core_1.Store {
      * @see https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html
      * @see https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSI.html
      */
-    find(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let scan = true;
-            let IndexName = undefined;
-            let result;
-            let primaryKeys = { uuid: null };
-            Object.keys(this.parameters.globalIndexes).forEach(name => {
-                primaryKeys[this.parameters.globalIndexes[name].key] = name;
-            });
-            // We could use PartQL but localstack is not compatible
-            let filter = new core_1.WebdaQL.AndExpression([]);
-            let KeyConditionExpression = "";
-            let ExpressionAttributeValues = {};
-            let FilterExpression = [];
-            let ExpressionAttributeNames = {};
-            let indexNode;
-            let sortOrder = "ASC";
-            let processingExpression;
-            if (!(query.filter instanceof core_1.WebdaQL.AndExpression)) {
-                processingExpression = new core_1.WebdaQL.AndExpression([query.filter]);
+    async find(query) {
+        let scan = true;
+        let IndexName = undefined;
+        let result;
+        let primaryKeys = { uuid: null };
+        Object.keys(this.parameters.globalIndexes).forEach(name => {
+            primaryKeys[this.parameters.globalIndexes[name].key] = name;
+        });
+        // We could use PartQL but localstack is not compatible
+        let filter = new WebdaQL.AndExpression([]);
+        let KeyConditionExpression = "";
+        let ExpressionAttributeValues = {};
+        let FilterExpression = [];
+        let ExpressionAttributeNames = {};
+        let indexNode;
+        let sortOrder = "ASC";
+        let processingExpression;
+        if (!(query.filter instanceof WebdaQL.AndExpression)) {
+            processingExpression = new WebdaQL.AndExpression([query.filter]);
+        }
+        else {
+            processingExpression = query.filter;
+        }
+        // Search for the index
+        processingExpression.children.some(child => {
+            if (child instanceof WebdaQL.ComparisonExpression) {
+                // Primary key requires equal operator
+                if (child.operator === "=" && primaryKeys[child.attribute[0]] !== undefined) {
+                    // Query not scan
+                    scan = false;
+                    IndexName = primaryKeys[child.attribute[0]];
+                    indexNode = child;
+                    KeyConditionExpression = `#${child.attribute[0]} = :${child.attribute[0]}`;
+                    ExpressionAttributeNames[`#${child.attribute[0]}`] = child.attribute[0];
+                    ExpressionAttributeValues[`:${child.attribute[0]}`] = child.value;
+                    if (primaryKeys[child.attribute[0]] !== null &&
+                        query.orderBy &&
+                        this.parameters.globalIndexes[primaryKeys[child.attribute[0]]].sort) {
+                        const sortKey = this.parameters.globalIndexes[primaryKeys[child.attribute[0]]].sort;
+                        // Might update sort order
+                        query.orderBy.some(order => {
+                            if (order.field === sortKey) {
+                                sortOrder = order.direction;
+                            }
+                        });
+                    }
+                    return true;
+                }
             }
-            else {
-                processingExpression = query.filter;
+        });
+        let count = 1;
+        // Build the Query/Filter
+        processingExpression.children.forEach(child => {
+            if (child === indexNode) {
+                return;
             }
-            // Search for the index
-            processingExpression.children.some(child => {
-                if (child instanceof core_1.WebdaQL.ComparisonExpression) {
-                    // Primary key requires equal operator
-                    if (child.operator === "=" && primaryKeys[child.attribute[0]] !== undefined) {
-                        // Query not scan
-                        scan = false;
-                        IndexName = primaryKeys[child.attribute[0]];
-                        indexNode = child;
-                        KeyConditionExpression = `#${child.attribute[0]} = :${child.attribute[0]}`;
-                        ExpressionAttributeNames[`#${child.attribute[0]}`] = child.attribute[0];
-                        ExpressionAttributeValues[`:${child.attribute[0]}`] = child.value;
-                        if (primaryKeys[child.attribute[0]] !== null &&
-                            query.orderBy &&
-                            this.parameters.globalIndexes[primaryKeys[child.attribute[0]]].sort) {
-                            const sortKey = this.parameters.globalIndexes[primaryKeys[child.attribute[0]]].sort;
-                            // Might update sort order
-                            query.orderBy.some(order => {
-                                if (order.field === sortKey) {
-                                    sortOrder = order.direction;
-                                }
-                            });
-                        }
-                        return true;
-                    }
+            // Only work on Comparison Node for now
+            if (child instanceof WebdaQL.ComparisonExpression) {
+                let operator = child.operator;
+                // DynamoDB does not manage LIKE
+                if (child.operator === "LIKE") {
+                    filter.children.push(child);
+                    return;
                 }
-            });
-            let count = 1;
-            // Build the Query/Filter
-            processingExpression.children.forEach(child => {
-                if (child === indexNode) {
+                // != is <> in Dynamo
+                if (operator === "!=") {
+                    operator = "<>";
+                }
+                // DynamoDB does not allow more than 100 items in IN
+                if (child.operator === "IN" && child.value.length > 100) {
+                    filter.children.push(child);
                     return;
                 }
-                // Only work on Comparison Node for now
-                if (child instanceof core_1.WebdaQL.ComparisonExpression) {
-                    let operator = child.operator;
-                    // DynamoDB does not manage LIKE
-                    if (child.operator === "LIKE") {
-                        filter.children.push(child);
-                        return;
-                    }
-                    // != is <> in Dynamo
-                    if (operator === "!=") {
-                        operator = "<>";
-                    }
-                    // DynamoDB does not allow more than 100 items in IN
-                    if (child.operator === "IN" && child.value.length > 100) {
-                        filter.children.push(child);
-                        return;
-                    }
-                    // Subfields like team.id needs to be #a1.#a2
-                    let attr = `a${count++}`;
-                    let fullAttr = `#${attr}`;
-                    child.attribute.splice(1).forEach(v => {
-                        let subAttr = `#a${count++}`;
-                        fullAttr += `.${subAttr}`;
-                        ExpressionAttributeNames[subAttr] = v;
+                // Subfields like team.id needs to be #a1.#a2
+                let attr = `a${count++}`;
+                let fullAttr = `#${attr}`;
+                child.attribute.splice(1).forEach(v => {
+                    let subAttr = `#a${count++}`;
+                    fullAttr += `.${subAttr}`;
+                    ExpressionAttributeNames[subAttr] = v;
+                });
+                ExpressionAttributeNames[`#${attr}`] = child.attribute[0];
+                let valueExpression = `:${attr}`;
+                if (child.operator === "IN") {
+                    // Need to follow `a IN (b, c, d)
+                    valueExpression = "(" + valueExpression;
+                    ExpressionAttributeValues[`:${attr}`] = child.value[0];
+                    child.value.splice(1).forEach(v => {
+                        let subAttr = `:a${count++}`;
+                        valueExpression += `, ${subAttr}`;
+                        ExpressionAttributeValues[subAttr] = v;
                     });
-                    ExpressionAttributeNames[`#${attr}`] = child.attribute[0];
-                    let valueExpression = `:${attr}`;
-                    if (child.operator === "IN") {
-                        // Need to follow `a IN (b, c, d)
-                        valueExpression = "(" + valueExpression;
-                        ExpressionAttributeValues[`:${attr}`] = child.value[0];
-                        child.value.splice(1).forEach(v => {
-                            let subAttr = `:a${count++}`;
-                            valueExpression += `, ${subAttr}`;
-                            ExpressionAttributeValues[subAttr] = v;
-                        });
-                        valueExpression += ")";
-                    }
-                    else {
-                        // For all other just give the value
-                        ExpressionAttributeValues[`:${attr}`] = child.value;
-                    }
-                    // If this is a sort key
-                    if (IndexName && this.parameters.globalIndexes[IndexName].sort === child.attribute[0]) {
-                        // Sort key
-                        KeyConditionExpression += ` AND ${fullAttr} ${operator} ${valueExpression}`;
-                        return;
-                    }
-                    // Otherwise fallback to normal Filter
-                    FilterExpression.push(`${fullAttr} ${operator} ${valueExpression}`);
+                    valueExpression += ")";
                 }
                 else {
-                    filter.children.push(child);
+                    // For all other just give the value
+                    ExpressionAttributeValues[`:${attr}`] = child.value;
                 }
-            });
-            if (!Object.keys(ExpressionAttributeNames).length) {
-                ExpressionAttributeNames = undefined;
-            }
-            if (!Object.keys(ExpressionAttributeValues).length) {
-                ExpressionAttributeValues = undefined;
-            }
-            const ExclusiveStartKey = query.continuationToken
-                ? JSON.parse(Buffer.from(query.continuationToken, "base64").toString())
-                : undefined;
-            // Scan if not primary key was provided
-            if (scan) {
-                // SHould log bad query
-                result = yield this._client.scan({
-                    TableName: this.parameters.table,
-                    FilterExpression: FilterExpression.length ? FilterExpression.join(" AND ") : undefined,
-                    ExclusiveStartKey,
-                    ExpressionAttributeNames,
-                    ExpressionAttributeValues,
-                    Limit: query.limit
-                });
+                // If this is a sort key
+                if (IndexName && this.parameters.globalIndexes[IndexName].sort === child.attribute[0]) {
+                    // Sort key
+                    KeyConditionExpression += ` AND ${fullAttr} ${operator} ${valueExpression}`;
+                    return;
+                }
+                // Otherwise fallback to normal Filter
+                FilterExpression.push(`${fullAttr} ${operator} ${valueExpression}`);
             }
             else {
-                result = yield this._client.query({
-                    TableName: this.parameters.table,
-                    IndexName,
-                    ExclusiveStartKey,
-                    KeyConditionExpression,
-                    FilterExpression: FilterExpression.length ? FilterExpression.join(" AND ") : undefined,
-                    ExpressionAttributeNames,
-                    ExpressionAttributeValues,
-                    Limit: query.limit,
-                    ScanIndexForward: sortOrder === "ASC" ? true : false
-                });
+                filter.children.push(child);
             }
-            return {
-                results: result.Items.map(c => this.initModel(c)),
-                filter,
-                continuationToken: result.Items.length >= query.limit
-                    ? Buffer.from(JSON.stringify(result.LastEvaluatedKey)).toString("base64")
-                    : undefined
-            };
         });
+        if (!Object.keys(ExpressionAttributeNames).length) {
+            ExpressionAttributeNames = undefined;
+        }
+        if (!Object.keys(ExpressionAttributeValues).length) {
+            ExpressionAttributeValues = undefined;
+        }
+        const ExclusiveStartKey = query.continuationToken
+            ? JSON.parse(Buffer.from(query.continuationToken, "base64").toString())
+            : undefined;
+        // Scan if not primary key was provided
+        if (scan) {
+            // SHould log bad query
+            result = await this._client.scan({
+                TableName: this.parameters.table,
+                FilterExpression: FilterExpression.length ? FilterExpression.join(" AND ") : undefined,
+                ExclusiveStartKey,
+                ExpressionAttributeNames,
+                ExpressionAttributeValues,
+                Limit: query.limit
+            });
+        }
+        else {
+            result = await this._client.query({
+                TableName: this.parameters.table,
+                IndexName,
+                ExclusiveStartKey,
+                KeyConditionExpression,
+                FilterExpression: FilterExpression.length ? FilterExpression.join(" AND ") : undefined,
+                ExpressionAttributeNames,
+                ExpressionAttributeValues,
+                Limit: query.limit,
+                ScanIndexForward: sortOrder === "ASC" ? true : false
+            });
+        }
+        return {
+            results: result.Items.map(c => this.initModel(c)),
+            filter,
+            continuationToken: result.Items.length >= query.limit
+                ? Buffer.from(JSON.stringify(result.LastEvaluatedKey)).toString("base64")
+                : undefined
+        };
     }
     /**
      * Serialize a date for DynamoDB
@@ -297,10 +275,10 @@ class DynamoStore extends core_1.Store {
         if (object instanceof Date) {
             return this._serializeDate(object);
         }
-        if (object instanceof core_1.CoreModel) {
+        if (object instanceof CoreModel) {
             object = object.toStoredJSON();
         }
-        var res;
+        let res;
         if (object instanceof Array) {
             res = [];
         }
@@ -318,139 +296,133 @@ class DynamoStore extends core_1.Store {
     /**
      * @inheritdoc
      */
-    _removeAttribute(uuid, attribute, itemWriteCondition, itemWriteConditionField) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var params = {
-                TableName: this.parameters.table,
-                Key: {
-                    uuid
-                }
-            };
-            var attrs = {};
-            attrs["#attr"] = attribute;
-            attrs["#lastUpdate"] = this._lastUpdateField;
-            params.ExpressionAttributeNames = attrs;
-            params.ConditionExpression = "attribute_exists(#uu)";
-            params.ExpressionAttributeValues = {
-                ":lastUpdate": this._serializeDate(new Date())
-            };
-            params.UpdateExpression = "REMOVE #attr SET #lastUpdate = :lastUpdate";
-            if (itemWriteCondition) {
-                this.setWriteCondition(params, itemWriteCondition, itemWriteConditionField);
-            }
-            else {
-                attrs["#uu"] = "uuid";
-                params.ConditionExpression = "attribute_exists(#uu)";
-            }
-            try {
-                yield this._client.update(params);
+    async _removeAttribute(uuid, attribute, itemWriteCondition, itemWriteConditionField) {
+        let params = {
+            TableName: this.parameters.table,
+            Key: {
+                uuid
             }
-            catch (err) {
-                if (err instanceof client_dynamodb_1.ConditionalCheckFailedException) {
-                    if (!itemWriteConditionField) {
-                        throw new core_1.StoreNotFoundError(uuid, this.getName());
-                    }
-                    throw new core_1.UpdateConditionFailError(uuid, itemWriteConditionField, itemWriteCondition);
+        };
+        let attrs = {};
+        attrs["#attr"] = attribute;
+        attrs["#lastUpdate"] = this._lastUpdateField;
+        params.ExpressionAttributeNames = attrs;
+        params.ConditionExpression = "attribute_exists(#uu)";
+        params.ExpressionAttributeValues = {
+            ":lastUpdate": this._serializeDate(new Date())
+        };
+        params.UpdateExpression = "REMOVE #attr SET #lastUpdate = :lastUpdate";
+        if (itemWriteCondition) {
+            this.setWriteCondition(params, itemWriteCondition, itemWriteConditionField);
+        }
+        else {
+            attrs["#uu"] = "uuid";
+            params.ConditionExpression = "attribute_exists(#uu)";
+        }
+        try {
+            await this._client.update(params);
+        }
+        catch (err) {
+            if (err instanceof ConditionalCheckFailedException) {
+                if (!itemWriteConditionField) {
+                    throw new StoreNotFoundError(uuid, this.getName());
                 }
-                throw err;
+                throw new UpdateConditionFailError(uuid, itemWriteConditionField, itemWriteCondition);
             }
-        });
+            throw err;
+        }
     }
     /**
      * @inheritdoc
      */
-    _deleteItemFromCollection(uid, prop, index, itemWriteCondition, itemWriteConditionField, updateDate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var params = {
-                TableName: this.parameters.table,
-                Key: {
-                    uuid: uid
-                }
-            };
-            var attrs = {};
-            attrs["#" + prop] = prop;
-            attrs["#lastUpdate"] = this._lastUpdateField;
-            params.ExpressionAttributeNames = attrs;
-            params.ExpressionAttributeValues = {
-                ":lastUpdate": this._serializeDate(updateDate)
-            };
-            params.UpdateExpression = "REMOVE #" + prop + "[" + index + "] SET #lastUpdate = :lastUpdate";
-            if (itemWriteCondition) {
-                params.ExpressionAttributeValues[":condValue"] = itemWriteCondition;
-                attrs["#condName"] = prop;
-                attrs["#field"] = itemWriteConditionField;
-                params.ConditionExpression = "#condName[" + index + "].#field = :condValue";
+    async _deleteItemFromCollection(uid, prop, index, itemWriteCondition, itemWriteConditionField, updateDate) {
+        let params = {
+            TableName: this.parameters.table,
+            Key: {
+                uuid: uid
             }
-            try {
-                yield this._client.update(params);
+        };
+        let attrs = {};
+        attrs["#" + prop] = prop;
+        attrs["#lastUpdate"] = this._lastUpdateField;
+        params.ExpressionAttributeNames = attrs;
+        params.ExpressionAttributeValues = {
+            ":lastUpdate": this._serializeDate(updateDate)
+        };
+        params.UpdateExpression = "REMOVE #" + prop + "[" + index + "] SET #lastUpdate = :lastUpdate";
+        if (itemWriteCondition) {
+            params.ExpressionAttributeValues[":condValue"] = itemWriteCondition;
+            attrs["#condName"] = prop;
+            attrs["#field"] = itemWriteConditionField;
+            params.ConditionExpression = "#condName[" + index + "].#field = :condValue";
+        }
+        try {
+            await this._client.update(params);
+        }
+        catch (err) {
+            if (err instanceof ConditionalCheckFailedException) {
+                throw new UpdateConditionFailError(uid, itemWriteConditionField, itemWriteCondition);
             }
-            catch (err) {
-                if (err instanceof client_dynamodb_1.ConditionalCheckFailedException) {
-                    throw new core_1.UpdateConditionFailError(uid, itemWriteConditionField, itemWriteCondition);
-                }
-                else if (err.name === "ValidationException") {
-                    throw new core_1.StoreNotFoundError(uid, this.getName());
-                }
-                throw err;
+            else if (err.name === "ValidationException") {
+                throw new StoreNotFoundError(uid, this.getName());
             }
-        });
+            throw err;
+        }
     }
     /**
      * @inheritdoc
      */
-    _upsertItemToCollection(uuid, prop, item, index, itemWriteCondition, itemWriteConditionField, updateDate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var params = {
-                TableName: this.parameters.table,
-                Key: {
-                    uuid
-                }
-            };
-            var attrValues = {};
-            var attrs = {};
-            attrs["#" + prop] = prop;
-            attrs["#lastUpdate"] = this._lastUpdateField;
-            attrValues[":" + prop] = this._cleanObject(item);
-            attrValues[":lastUpdate"] = this._serializeDate(updateDate);
-            attrValues[":uuid"] = uuid;
-            attrs["#uuid"] = this._uuidField;
-            params.ConditionExpression = "#uuid = :uuid";
-            params.ExpressionAttributeValues = attrValues;
-            params.ExpressionAttributeNames = attrs;
-            if (index === undefined) {
-                params.UpdateExpression =
-                    "SET #" +
-                        prop +
-                        "= list_append(if_not_exists (#" +
-                        prop +
-                        ", :empty_list),:" +
-                        prop +
-                        "), #lastUpdate = :lastUpdate";
-                attrValues[":" + prop] = [attrValues[":" + prop]];
-                attrValues[":empty_list"] = [];
+    async _upsertItemToCollection(uuid, prop, item, index, itemWriteCondition, itemWriteConditionField, updateDate) {
+        let params = {
+            TableName: this.parameters.table,
+            Key: {
+                uuid
             }
-            else {
-                params.UpdateExpression = "SET #" + prop + "[" + index + "] = :" + prop + ", #lastUpdate = :lastUpdate";
-                if (itemWriteCondition) {
-                    attrValues[":condValue"] = itemWriteCondition;
-                    attrs["#condName"] = prop;
-                    attrs["#field"] = itemWriteConditionField;
-                    params.ConditionExpression = "#condName[" + index + "].#field = :condValue and #uuid = :uuid";
-                }
+        };
+        let attrValues = {};
+        let attrs = {};
+        attrs["#" + prop] = prop;
+        attrs["#lastUpdate"] = this._lastUpdateField;
+        attrValues[":" + prop] = this._cleanObject(item);
+        attrValues[":lastUpdate"] = this._serializeDate(updateDate);
+        attrValues[":uuid"] = uuid;
+        attrs["#uuid"] = this._uuidField;
+        params.ConditionExpression = "#uuid = :uuid";
+        params.ExpressionAttributeValues = attrValues;
+        params.ExpressionAttributeNames = attrs;
+        if (index === undefined) {
+            params.UpdateExpression =
+                "SET #" +
+                    prop +
+                    "= list_append(if_not_exists (#" +
+                    prop +
+                    ", :empty_list),:" +
+                    prop +
+                    "), #lastUpdate = :lastUpdate";
+            attrValues[":" + prop] = [attrValues[":" + prop]];
+            attrValues[":empty_list"] = [];
+        }
+        else {
+            params.UpdateExpression = "SET #" + prop + "[" + index + "] = :" + prop + ", #lastUpdate = :lastUpdate";
+            if (itemWriteCondition) {
+                attrValues[":condValue"] = itemWriteCondition;
+                attrs["#condName"] = prop;
+                attrs["#field"] = itemWriteConditionField;
+                params.ConditionExpression = "#condName[" + index + "].#field = :condValue and #uuid = :uuid";
             }
-            try {
-                yield this._client.update(params);
+        }
+        try {
+            await this._client.update(params);
+        }
+        catch (err) {
+            if (err instanceof ConditionalCheckFailedException) {
+                throw new UpdateConditionFailError(uuid, itemWriteConditionField, itemWriteCondition);
             }
-            catch (err) {
-                if (err instanceof client_dynamodb_1.ConditionalCheckFailedException) {
-                    throw new core_1.UpdateConditionFailError(uuid, itemWriteConditionField, itemWriteCondition);
-                }
-                else if (err.name === "ValidationException") {
-                    throw new core_1.StoreNotFoundError(uuid, this.getName());
-                }
-                throw err;
+            else if (err.name === "ValidationException") {
+                throw new StoreNotFoundError(uuid, this.getName());
             }
-        });
+            throw err;
+        }
     }
     /**
      * REturn the write condition as string
@@ -459,9 +431,8 @@ class DynamoStore extends core_1.Store {
      * @returns
      */
     setWriteCondition(params, writeCondition, field = this._lastUpdateField) {
-        var _a, _b;
-        (_a = params.ExpressionAttributeNames) !== null && _a !== void 0 ? _a : (params.ExpressionAttributeNames = {});
-        (_b = params.ExpressionAttributeValues) !== null && _b !== void 0 ? _b : (params.ExpressionAttributeValues = {});
+        params.ExpressionAttributeNames ?? (params.ExpressionAttributeNames = {});
+        params.ExpressionAttributeValues ?? (params.ExpressionAttributeValues = {});
         params.ExpressionAttributeNames["#cf"] = field;
         if (writeCondition instanceof Date) {
             writeCondition = this._serializeDate(writeCondition);
@@ -472,199 +443,185 @@ class DynamoStore extends core_1.Store {
     /**
      * @inheritdoc
      */
-    _delete(uid, writeCondition, itemWriteConditionField) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var params = {
-                TableName: this.parameters.table,
-                Key: {
-                    uuid: uid
-                }
-            };
-            if (writeCondition) {
-                this.setWriteCondition(params, writeCondition, itemWriteConditionField);
-            }
-            try {
-                yield this._client.delete(params);
+    async _delete(uid, writeCondition, itemWriteConditionField) {
+        let params = {
+            TableName: this.parameters.table,
+            Key: {
+                uuid: uid
             }
-            catch (err) {
-                if (err instanceof client_dynamodb_1.ConditionalCheckFailedException) {
-                    throw new core_1.UpdateConditionFailError(uid, itemWriteConditionField, writeCondition);
-                }
-                throw err;
+        };
+        if (writeCondition) {
+            this.setWriteCondition(params, writeCondition, itemWriteConditionField);
+        }
+        try {
+            await this._client.delete(params);
+        }
+        catch (err) {
+            if (err instanceof ConditionalCheckFailedException) {
+                throw new UpdateConditionFailError(uid, itemWriteConditionField, writeCondition);
             }
-        });
+            throw err;
+        }
     }
     /**
      * @inheritdoc
      */
-    _patch(object, uid, itemWriteCondition, itemWriteConditionField) {
-        return __awaiter(this, void 0, void 0, function* () {
-            object = this._cleanObject(object);
-            var expr = "SET ";
-            var sep = "";
-            var attrValues = {};
-            var attrs = {};
-            var skipUpdate = true;
-            var i = 1;
-            for (var attr in object) {
-                if (attr === "uuid" || object[attr] === undefined) {
-                    continue;
-                }
-                skipUpdate = false;
-                expr += sep + "#a" + i + " = :v" + i;
-                attrValues[":v" + i] = object[attr];
-                attrs["#a" + i] = attr;
-                sep = ",";
-                i++;
-            }
-            if (skipUpdate) {
-                return;
-            }
-            var params = {
-                TableName: this.parameters.table,
-                Key: {
-                    uuid: uid
-                },
-                UpdateExpression: expr,
-                ExpressionAttributeValues: attrValues,
-                ExpressionAttributeNames: attrs
-            };
-            // The Write Condition checks the value before writing
-            if (itemWriteCondition) {
-                this.setWriteCondition(params, itemWriteCondition, itemWriteConditionField);
-            }
-            try {
-                yield this._client.update(params);
+    async _patch(object, uid, itemWriteCondition, itemWriteConditionField) {
+        object = this._cleanObject(object);
+        let expr = "SET ";
+        let sep = "";
+        let attrValues = {};
+        let attrs = {};
+        let skipUpdate = true;
+        let i = 1;
+        for (let attr in object) {
+            if (attr === "uuid" || object[attr] === undefined) {
+                continue;
             }
-            catch (err) {
-                if (err instanceof client_dynamodb_1.ConditionalCheckFailedException) {
-                    throw new core_1.UpdateConditionFailError(uid, itemWriteConditionField, itemWriteCondition);
-                }
-                throw err;
+            skipUpdate = false;
+            expr += sep + "#a" + i + " = :v" + i;
+            attrValues[":v" + i] = object[attr];
+            attrs["#a" + i] = attr;
+            sep = ",";
+            i++;
+        }
+        if (skipUpdate) {
+            return;
+        }
+        let params = {
+            TableName: this.parameters.table,
+            Key: {
+                uuid: uid
+            },
+            UpdateExpression: expr,
+            ExpressionAttributeValues: attrValues,
+            ExpressionAttributeNames: attrs
+        };
+        // The Write Condition checks the value before writing
+        if (itemWriteCondition) {
+            this.setWriteCondition(params, itemWriteCondition, itemWriteConditionField);
+        }
+        try {
+            await this._client.update(params);
+        }
+        catch (err) {
+            if (err instanceof ConditionalCheckFailedException) {
+                throw new UpdateConditionFailError(uid, itemWriteConditionField, itemWriteCondition);
             }
-        });
+            throw err;
+        }
     }
     /**
      * @inheritdoc
      */
-    _update(object, uid, itemWriteCondition, itemWriteConditionField) {
-        return __awaiter(this, void 0, void 0, function* () {
-            object = this._cleanObject(object);
-            object.uuid = uid;
-            var params = {
-                TableName: this.parameters.table,
-                Item: object
-            };
-            // The Write Condition checks the value before writing
-            if (itemWriteCondition) {
-                this.setWriteCondition(params, itemWriteCondition, itemWriteConditionField);
-            }
-            try {
-                yield this._client.put(params);
-                return object;
-            }
-            catch (err) {
-                if (err instanceof client_dynamodb_1.ConditionalCheckFailedException) {
-                    throw new core_1.UpdateConditionFailError(uid, itemWriteConditionField, itemWriteCondition);
-                }
-                throw err;
+    async _update(object, uid, itemWriteCondition, itemWriteConditionField) {
+        object = this._cleanObject(object);
+        object.uuid = uid;
+        let params = {
+            TableName: this.parameters.table,
+            Item: object
+        };
+        // The Write Condition checks the value before writing
+        if (itemWriteCondition) {
+            this.setWriteCondition(params, itemWriteCondition, itemWriteConditionField);
+        }
+        try {
+            await this._client.put(params);
+            return object;
+        }
+        catch (err) {
+            if (err instanceof ConditionalCheckFailedException) {
+                throw new UpdateConditionFailError(uid, itemWriteConditionField, itemWriteCondition);
             }
-        });
+            throw err;
+        }
     }
     /**
      * @inheritdoc
      */
-    _scan(items = [], paging = undefined) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let data = yield this._client.scan({
-                TableName: this.parameters.table,
-                Limit: this.parameters.scanPage,
-                ExclusiveStartKey: paging
-            });
-            for (let i in data.Items) {
-                items.push(this.initModel(data.Items[i]));
-            }
-            if (data.LastEvaluatedKey) {
-                return this._scan(items, data.LastEvaluatedKey);
-            }
-            return items;
+    async _scan(items = [], paging = undefined) {
+        let data = await this._client.scan({
+            TableName: this.parameters.table,
+            Limit: this.parameters.scanPage,
+            ExclusiveStartKey: paging
         });
+        for (let i in data.Items) {
+            items.push(this.initModel(data.Items[i]));
+        }
+        if (data.LastEvaluatedKey) {
+            return this._scan(items, data.LastEvaluatedKey);
+        }
+        return items;
     }
     /**
      * @inheritdoc
      */
-    getAll(uids) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!uids) {
-                return this._scan([]);
-            }
-            var params = {
-                RequestItems: {}
-            };
-            params["RequestItems"][this.parameters.table] = {
-                Keys: uids.map(value => {
-                    return {
-                        uuid: value
-                    };
-                })
-            };
-            let result = yield this._client.batchGet(params);
-            return result.Responses[this.parameters.table].map(this.initModel, this);
-        });
+    async getAll(uids) {
+        if (!uids) {
+            return this._scan([]);
+        }
+        let params = {
+            RequestItems: {}
+        };
+        params["RequestItems"][this.parameters.table] = {
+            Keys: uids.map(value => {
+                return {
+                    uuid: value
+                };
+            })
+        };
+        let result = await this._client.batchGet(params);
+        return result.Responses[this.parameters.table].map(this.initModel, this);
     }
     /**
      * @inheritdoc
      */
-    _get(uid, raiseIfNotFound = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var params = {
-                TableName: this.parameters.table,
-                Key: {
-                    uuid: uid
-                }
-            };
-            let item = (yield this._client.get(params)).Item;
-            if (!item) {
-                if (raiseIfNotFound) {
-                    throw new core_1.StoreNotFoundError(uid, this.getName());
-                }
-                return undefined;
+    async _get(uid, raiseIfNotFound = false) {
+        let params = {
+            TableName: this.parameters.table,
+            Key: {
+                uuid: uid
             }
-            return this.initModel(item);
-        });
+        };
+        let item = (await this._client.get(params)).Item;
+        if (!item) {
+            if (raiseIfNotFound) {
+                throw new StoreNotFoundError(uid, this.getName());
+            }
+            return undefined;
+        }
+        return this.initModel(item);
     }
     /**
      * @inheritdoc
      */
-    _incrementAttribute(uid, prop, value, updateDate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var params = {
-                TableName: this.parameters.table,
-                Key: {
-                    uuid: uid
-                },
-                UpdateExpression: "SET #a2 = :v2 ADD #a1 :v1",
-                ConditionExpression: "attribute_exists(#uu)",
-                ExpressionAttributeValues: {
-                    ":v1": value,
-                    ":v2": this._serializeDate(updateDate)
-                },
-                ExpressionAttributeNames: {
-                    "#a1": prop,
-                    "#a2": this._lastUpdateField,
-                    "#uu": "uuid"
-                }
-            };
-            try {
-                return yield this._client.update(params);
+    async _incrementAttribute(uid, prop, value, updateDate) {
+        let params = {
+            TableName: this.parameters.table,
+            Key: {
+                uuid: uid
+            },
+            UpdateExpression: "SET #a2 = :v2 ADD #a1 :v1",
+            ConditionExpression: "attribute_exists(#uu)",
+            ExpressionAttributeValues: {
+                ":v1": value,
+                ":v2": this._serializeDate(updateDate)
+            },
+            ExpressionAttributeNames: {
+                "#a1": prop,
+                "#a2": this._lastUpdateField,
+                "#uu": "uuid"
             }
-            catch (err) {
-                if (err instanceof client_dynamodb_1.ConditionalCheckFailedException) {
-                    throw new core_1.StoreNotFoundError(uid, this.getName());
-                }
-                throw err;
+        };
+        try {
+            return await this._client.update(params);
+        }
+        catch (err) {
+            if (err instanceof ConditionalCheckFailedException) {
+                throw new StoreNotFoundError(uid, this.getName());
             }
-        });
+            throw err;
+        }
     }
     /**
      * @inheritdoc
@@ -692,18 +649,16 @@ class DynamoStore extends core_1.Store {
     /**
      * @inheritdoc
      */
-    __clean() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var params = {
-                TableName: this.parameters.table
-            };
-            let result = yield this._client.scan(params);
-            var promises = [];
-            for (var i in result.Items) {
-                promises.push(this._delete(result.Items[i].uuid));
-            }
-            yield Promise.all(promises);
-        });
+    async __clean() {
+        let params = {
+            TableName: this.parameters.table
+        };
+        let result = await this._client.scan(params);
+        let promises = [];
+        for (let i in result.Items) {
+            promises.push(this._delete(result.Items[i].uuid));
+        }
+        await Promise.all(promises);
     }
     /**
      * @inheritdoc
@@ -722,13 +677,17 @@ class DynamoStore extends core_1.Store {
         AttributeDefinitions.push({ AttributeName: "uuid", AttributeType: "S" });
         resources[this._name + "DynamoTable"] = {
             Type: "AWS::DynamoDB::Table",
-            Properties: Object.assign(Object.assign({}, this.parameters.CloudFormation.Table), { TableName: this.parameters.table, KeySchema,
-                AttributeDefinitions, Tags: deployer.getDefaultTags(this.parameters.CloudFormation.Table.Tags) })
+            Properties: {
+                ...this.parameters.CloudFormation.Table,
+                TableName: this.parameters.table,
+                KeySchema,
+                AttributeDefinitions,
+                Tags: deployer.getDefaultTags(this.parameters.CloudFormation.Table.Tags)
+            }
         };
         // Add any Other resources with prefix of the service
         return resources;
     }
 }
-exports.default = DynamoStore;
-exports.DynamoStore = DynamoStore;
+export { DynamoStore };
 //# sourceMappingURL=dynamodb.js.map