@monorise/core 0.1.1 → 0.1.3

package/dist/core/data/Entity.js

@@ -1,3 +1,12 @@
+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());
+    });
+};
 import { ConditionalCheckFailedException, } from '@aws-sdk/client-dynamodb';
 import { marshall, unmarshall } from '@aws-sdk/util-dynamodb';
 import { ulid } from 'ulid';
@@ -5,12 +14,6 @@ import { StandardError } from '../errors/standard-error';
 import { Item } from './abstract/Item.base';
 import { Repository } from './abstract/Repository.base';
 export class Entity extends Item {
-    entityType;
-    entityId;
-    data;
-    _createdAt;
-    _updatedAt;
-    fullId;
     constructor(entityType, entityId, data = {}, _createdAt, _updatedAt) {
         super();
         this.entityType = entityType;
@@ -46,16 +49,15 @@ export class Entity extends Item {
         };
     }
     get createdAt() {
-        return this._createdAt?.toISOString();
+        var _a;
+        return (_a = this._createdAt) === null || _a === void 0 ? void 0 : _a.toISOString();
     }
     get updatedAt() {
-        return this._updatedAt?.toISOString();
+        var _a;
+        return (_a = this._updatedAt) === null || _a === void 0 ? void 0 : _a.toISOString();
     }
     toItem() {
-        return {
-            ...marshall(this.toJSON(), { removeUndefinedValues: true }),
-            ...this.keys(),
-        };
+        return Object.assign(Object.assign({}, marshall(this.toJSON(), { removeUndefinedValues: true })), this.keys());
     }
     toJSON() {
         return {
@@ -68,10 +70,6 @@ export class Entity extends Item {
     }
 }
 export class EntityRepository extends Repository {
-    EntityConfig;
-    TABLE_NAME;
-    dynamodbClient;
-    EmailAuthEnabledEntities;
     constructor(EntityConfig, TABLE_NAME, dynamodbClient, EmailAuthEnabledEntities) {
         super();
         this.EntityConfig = EntityConfig;
@@ -79,147 +77,154 @@ export class EntityRepository extends Repository {
         this.dynamodbClient = dynamodbClient;
         this.EmailAuthEnabledEntities = EmailAuthEnabledEntities;
     }
-    async listEntities({ entityType, limit, // if this is not set, it will return all items
-    between, options = {}, }) {
-        const entity = new Entity(entityType);
-        // when query for records that SK are between provided start and end
-        const expression = between
-            ? {
-                KeyConditionExpression: '#PK = :PK and #SK between :SKStart and :SKEnd',
+    listEntities(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ entityType, limit, // if this is not set, it will return all items
+        between, options = {}, }) {
+            var _b, _c, _d;
+            const entity = new Entity(entityType);
+            // when query for records that SK are between provided start and end
+            const expression = between
+                ? {
+                    KeyConditionExpression: '#PK = :PK and #SK between :SKStart and :SKEnd',
+                    ExpressionAttributeNames: {
+                        '#PK': 'PK',
+                        '#SK': 'SK',
+                    },
+                    ExpressionAttributeValues: {
+                        ':PK': {
+                            S: entity.listActionKey,
+                        },
+                        ':SKStart': {
+                            S: `${entityType}#${between.start}`,
+                        },
+                        ':SKEnd': {
+                            S: `${entityType}#${between.end}`,
+                        },
+                    },
+                }
+                : {
+                    KeyConditionExpression: '#PK = :PK',
+                    ExpressionAttributeNames: {
+                        '#PK': 'PK',
+                    },
+                    ExpressionAttributeValues: {
+                        ':PK': {
+                            S: entity.listActionKey,
+                        },
+                    },
+                };
+            const defaultListQuery = Object.assign({ TableName: this.TABLE_NAME, Limit: limit, ScanIndexForward: false, ProjectionExpression: options === null || options === void 0 ? void 0 : options.ProjectionExpression }, expression);
+            let lastKey = options.lastKey;
+            let items = [];
+            let remainingCount = limit !== null && limit !== void 0 ? limit : 0;
+            do {
+                const resp = yield this.dynamodbClient.query(Object.assign(Object.assign(Object.assign({}, defaultListQuery), (remainingCount && { Limit: remainingCount })), (lastKey && {
+                    ExclusiveStartKey: lastKey,
+                })));
+                items = items.concat((_b = resp.Items) !== null && _b !== void 0 ? _b : []);
+                lastKey = resp.LastEvaluatedKey;
+                if (limit) {
+                    remainingCount = remainingCount - ((_d = (_c = resp.Items) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0);
+                }
+            } while (
+            // limit is given, haven't reach limit, and there are still items to retrieve
+            (limit && remainingCount && lastKey) ||
+                // no limit is given and there are still items to retrieve
+                (!limit && lastKey));
+            return {
+                items: (items || []).map((Entity.fromItem)),
+                totalCount: items.length,
+                lastKey,
+            };
+        });
+    }
+    getEntity(entityType, entityId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entity = new Entity(entityType, entityId);
+            const resp = yield this.dynamodbClient.getItem({
+                TableName: this.TABLE_NAME,
+                Key: entity.keys(),
+            });
+            return Entity.fromItem(resp.Item);
+        });
+    }
+    getEntityByEmail(entityType, email) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const resp = yield this.dynamodbClient.query({
+                TableName: this.TABLE_NAME,
+                KeyConditionExpression: '#PK = :PK and begins_with(#SK, :SK)',
                 ExpressionAttributeNames: {
                     '#PK': 'PK',
                     '#SK': 'SK',
                 },
                 ExpressionAttributeValues: {
-                    ':PK': {
-                        S: entity.listActionKey,
-                    },
-                    ':SKStart': {
-                        S: `${entityType}#${between.start}`,
-                    },
-                    ':SKEnd': {
-                        S: `${entityType}#${between.end}`,
-                    },
+                    ':PK': { S: `EMAIL#${email}` },
+                    ':SK': { S: entityType },
                 },
-            }
-            : {
-                KeyConditionExpression: '#PK = :PK',
+            });
+            return Entity.fromItem((_a = resp.Items) === null || _a === void 0 ? void 0 : _a[0]);
+        });
+    }
+    getEmailAvailability(entityType, email) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const resp = yield this.dynamodbClient.query({
+                TableName: this.TABLE_NAME,
+                KeyConditionExpression: '#PK = :PK and begins_with(#SK, :SK)',
                 ExpressionAttributeNames: {
                     '#PK': 'PK',
+                    '#SK': 'SK',
                 },
                 ExpressionAttributeValues: {
-                    ':PK': {
-                        S: entity.listActionKey,
-                    },
+                    ':PK': { S: `EMAIL#${email}` },
+                    ':SK': { S: entityType },
                 },
-            };
-        const defaultListQuery = {
-            TableName: this.TABLE_NAME,
-            Limit: limit,
-            ScanIndexForward: false,
-            ProjectionExpression: options?.ProjectionExpression,
-            ...expression,
-        };
-        let lastKey = options.lastKey;
-        let items = [];
-        let remainingCount = limit ?? 0;
-        do {
-            const resp = await this.dynamodbClient.query({
-                ...defaultListQuery,
-                ...(remainingCount && { Limit: remainingCount }),
-                ...(lastKey && {
-                    ExclusiveStartKey: lastKey,
-                }),
             });
-            items = items.concat(resp.Items ?? []);
-            lastKey = resp.LastEvaluatedKey;
-            if (limit) {
-                remainingCount = remainingCount - (resp.Items?.length ?? 0);
+            if ((_a = resp.Items) === null || _a === void 0 ? void 0 : _a[0]) {
+                throw new StandardError('EMAIL_EXISTS', 'Email already exists');
             }
-        } while (
-        // limit is given, haven't reach limit, and there are still items to retrieve
-        (limit && remainingCount && lastKey) ||
-            // no limit is given and there are still items to retrieve
-            (!limit && lastKey));
-        return {
-            items: (items || []).map((Entity.fromItem)),
-            totalCount: items.length,
-            lastKey,
-        };
-    }
-    async getEntity(entityType, entityId) {
-        const entity = new Entity(entityType, entityId);
-        const resp = await this.dynamodbClient.getItem({
-            TableName: this.TABLE_NAME,
-            Key: entity.keys(),
+            return;
         });
-        return Entity.fromItem(resp.Item);
     }
-    async getEntityByEmail(entityType, email) {
-        const resp = await this.dynamodbClient.query({
-            TableName: this.TABLE_NAME,
-            KeyConditionExpression: '#PK = :PK and begins_with(#SK, :SK)',
-            ExpressionAttributeNames: {
-                '#PK': 'PK',
-                '#SK': 'SK',
-            },
-            ExpressionAttributeValues: {
-                ':PK': { S: `EMAIL#${email}` },
-                ':SK': { S: entityType },
-            },
-        });
-        return Entity.fromItem(resp.Items?.[0]);
-    }
-    async getEmailAvailability(entityType, email) {
-        const resp = await this.dynamodbClient.query({
-            TableName: this.TABLE_NAME,
-            KeyConditionExpression: '#PK = :PK and begins_with(#SK, :SK)',
-            ExpressionAttributeNames: {
-                '#PK': 'PK',
-                '#SK': 'SK',
-            },
-            ExpressionAttributeValues: {
-                ':PK': { S: `EMAIL#${email}` },
-                ':SK': { S: entityType },
-            },
-        });
-        if (resp.Items?.[0]) {
-            throw new StandardError('EMAIL_EXISTS', 'Email already exists');
-        }
-        return;
-    }
-    async getEntityByUniqueField(entityType, fieldName, value) {
-        const resp = await this.dynamodbClient.query({
-            TableName: this.TABLE_NAME,
-            KeyConditionExpression: '#PK = :PK and begins_with(#SK, :SK)',
-            ExpressionAttributeNames: {
-                '#PK': 'PK',
-                '#SK': 'SK',
-            },
-            ExpressionAttributeValues: {
-                ':PK': { S: `UNIQUE#${fieldName}#${value}` },
-                ':SK': { S: entityType },
-            },
+    getEntityByUniqueField(entityType, fieldName, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const resp = yield this.dynamodbClient.query({
+                TableName: this.TABLE_NAME,
+                KeyConditionExpression: '#PK = :PK and begins_with(#SK, :SK)',
+                ExpressionAttributeNames: {
+                    '#PK': 'PK',
+                    '#SK': 'SK',
+                },
+                ExpressionAttributeValues: {
+                    ':PK': { S: `UNIQUE#${fieldName}#${value}` },
+                    ':SK': { S: entityType },
+                },
+            });
+            return Entity.fromItem((_a = resp.Items) === null || _a === void 0 ? void 0 : _a[0]);
         });
-        return Entity.fromItem(resp.Items?.[0]);
     }
-    async getUniqueFieldValueAvailability(entityType, fieldName, value) {
-        const resp = await this.dynamodbClient.query({
-            TableName: this.TABLE_NAME,
-            KeyConditionExpression: '#PK = :PK and begins_with(#SK, :SK)',
-            ExpressionAttributeNames: {
-                '#PK': 'PK',
-                '#SK': 'SK',
-            },
-            ExpressionAttributeValues: {
-                ':PK': { S: `UNIQUE#${fieldName}#${value}` },
-                ':SK': { S: entityType },
-            },
+    getUniqueFieldValueAvailability(entityType, fieldName, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const resp = yield this.dynamodbClient.query({
+                TableName: this.TABLE_NAME,
+                KeyConditionExpression: '#PK = :PK and begins_with(#SK, :SK)',
+                ExpressionAttributeNames: {
+                    '#PK': 'PK',
+                    '#SK': 'SK',
+                },
+                ExpressionAttributeValues: {
+                    ':PK': { S: `UNIQUE#${fieldName}#${value}` },
+                    ':SK': { S: entityType },
+                },
+            });
+            if ((_a = resp.Items) === null || _a === void 0 ? void 0 : _a[0]) {
+                throw new StandardError('UNIQUE_VALUE_EXISTS', `${fieldName} '${value}' already exists`);
+            }
+            return;
         });
-        if (resp.Items?.[0]) {
-            throw new StandardError('UNIQUE_VALUE_EXISTS', `${fieldName} '${value}' already exists`);
-        }
-        return;
     }
     createEntityTransactItems(entity, opts) {
         const TransactItems = [
@@ -227,26 +232,17 @@ export class EntityRepository extends Repository {
                 Put: {
                     TableName: this.TABLE_NAME,
                     ConditionExpression: 'attribute_not_exists(PK)',
-                    Item: {
-                        ...entity.toItem(),
-                        ...(opts?.mutualId && {
-                            R2PK: { S: opts.mutualId },
-                            R2SK: { S: entity.pk },
-                        }),
-                    },
+                    Item: Object.assign(Object.assign({}, entity.toItem()), ((opts === null || opts === void 0 ? void 0 : opts.mutualId) && {
+                        R2PK: { S: opts.mutualId },
+                        R2SK: { S: entity.pk },
+                    })),
                 },
             },
             {
                 Put: {
                     TableName: this.TABLE_NAME,
                     ConditionExpression: 'attribute_not_exists(PK)',
-                    Item: {
-                        ...entity.toItem(),
-                        PK: { S: entity.listActionKey },
-                        SK: entity.keys().PK,
-                        R1PK: entity.keys().PK,
-                        R1SK: { S: entity.listActionKey },
-                    },
+                    Item: Object.assign(Object.assign({}, entity.toItem()), { PK: { S: entity.listActionKey }, SK: entity.keys().PK, R1PK: entity.keys().PK, R1SK: { S: entity.listActionKey } }),
                 },
             },
         ];
@@ -259,12 +255,7 @@ export class EntityRepository extends Repository {
                 Put: {
                     TableName: this.TABLE_NAME,
                     ConditionExpression: 'attribute_not_exists(PK)',
-                    Item: {
-                        ...entity.toItem(),
-                        ...entity.emailKeys,
-                        R1PK: entity.emailKeys.SK,
-                        R1SK: entity.emailKeys.PK,
-                    },
+                    Item: Object.assign(Object.assign(Object.assign({}, entity.toItem()), entity.emailKeys), { R1PK: entity.emailKeys.SK, R1SK: entity.emailKeys.PK }),
                 },
             });
         }
@@ -273,76 +264,65 @@ export class EntityRepository extends Repository {
                 Put: {
                     TableName: this.TABLE_NAME,
                     ConditionExpression: 'attribute_not_exists(PK)',
-                    Item: {
-                        ...entity.toItem(),
-                        PK: {
+                    Item: Object.assign(Object.assign({}, entity.toItem()), { PK: {
                             S: `UNIQUE#${field}#${entity.data[field]}`,
-                        },
-                        SK: { S: entity.entityType },
-                        R1PK: entity.keys().PK,
-                        R1SK: entity.keys().SK,
-                    },
+                        }, SK: { S: entity.entityType }, R1PK: entity.keys().PK, R1SK: entity.keys().SK }),
                 },
             });
         }
         return TransactItems;
     }
-    async createEntity(entityType, entityPayload, entityId, opts) {
-        const currentDatetime = opts?.createAndUpdateDatetime ?? new Date();
-        const entity = new Entity(entityType, entityId || ulid(), entityPayload, currentDatetime, currentDatetime);
-        const uniqueFields = (this.EntityConfig[entityType].uniqueFields ||
-            []);
-        const hasUniqueFields = Object.keys(entityPayload).some((field) => uniqueFields.includes(field));
-        let uniqueFieldValues = {};
-        if (hasUniqueFields) {
-            for (const field of uniqueFields) {
-                if (typeof entityPayload[field] !== 'string') {
-                    throw new StandardError('INVALID_UNIQUE_VALUE_TYPE', `Invalid type. ${field} is not a 'string'.`);
+    createEntity(entityType, entityPayload, entityId, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const currentDatetime = (_a = opts === null || opts === void 0 ? void 0 : opts.createAndUpdateDatetime) !== null && _a !== void 0 ? _a : new Date();
+            const entity = new Entity(entityType, entityId || ulid(), entityPayload, currentDatetime, currentDatetime);
+            const uniqueFields = (this.EntityConfig[entityType].uniqueFields ||
+                []);
+            const hasUniqueFields = Object.keys(entityPayload).some((field) => uniqueFields.includes(field));
+            let uniqueFieldValues = {};
+            if (hasUniqueFields) {
+                for (const field of uniqueFields) {
+                    if (typeof entityPayload[field] !== 'string') {
+                        throw new StandardError('INVALID_UNIQUE_VALUE_TYPE', `Invalid type. ${field} is not a 'string'.`);
+                    }
                 }
+                uniqueFieldValues = uniqueFields.reduce((acc, field) => (Object.assign(Object.assign({}, acc), { [field]: entityPayload[field] })), {});
             }
-            uniqueFieldValues = uniqueFields.reduce((acc, field) => ({
-                ...acc,
-                [field]: entityPayload[field],
-            }), {});
-        }
-        const TransactItems = this.createEntityTransactItems(entity, {
-            mutualId: opts?.mutualId,
-            uniqueFieldValues,
+            const TransactItems = this.createEntityTransactItems(entity, {
+                mutualId: opts === null || opts === void 0 ? void 0 : opts.mutualId,
+                uniqueFieldValues,
+            });
+            yield this.dynamodbClient.transactWriteItems({ TransactItems });
+            return entity;
         });
-        await this.dynamodbClient.transactWriteItems({ TransactItems });
-        return entity;
     }
-    async upsertEntity(entityType, entityId, payload) {
-        const currentDatetime = new Date().toISOString();
-        const toUpdateExpressions = this.toUpdate({
-            entityType,
-            entityId,
-            data: payload,
-            updatedAt: currentDatetime,
+    upsertEntity(entityType, entityId, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentDatetime = new Date().toISOString();
+            const toUpdateExpressions = this.toUpdate({
+                entityType,
+                entityId,
+                data: payload,
+                updatedAt: currentDatetime,
+            });
+            const params = {
+                TableName: this.TABLE_NAME,
+                ReturnValues: 'ALL_NEW',
+                Key: new Entity(entityType, entityId).keys(),
+                UpdateExpression: toUpdateExpressions.UpdateExpression,
+                ExpressionAttributeNames: Object.assign({}, toUpdateExpressions.ExpressionAttributeNames),
+                ExpressionAttributeValues: Object.assign({}, toUpdateExpressions.ExpressionAttributeValues),
+            };
+            const resp = yield this.dynamodbClient.updateItem(params);
+            const updatedEntity = Entity.fromItem(resp.Attributes);
+            return updatedEntity;
         });
-        const params = {
-            TableName: this.TABLE_NAME,
-            ReturnValues: 'ALL_NEW',
-            Key: new Entity(entityType, entityId).keys(),
-            UpdateExpression: toUpdateExpressions.UpdateExpression,
-            ExpressionAttributeNames: {
-                ...toUpdateExpressions.ExpressionAttributeNames,
-            },
-            ExpressionAttributeValues: {
-                ...toUpdateExpressions.ExpressionAttributeValues,
-            },
-        };
-        const resp = await this.dynamodbClient.updateItem(params);
-        const updatedEntity = Entity.fromItem(resp.Attributes);
-        return updatedEntity;
     }
     updateEntityTransactItems(entity, updateParams, previousUniqueFieldValues, previousEntity) {
         const transactItems = [
             {
-                Update: {
-                    ...updateParams,
-                    UpdateExpression: updateParams.UpdateExpression,
-                },
+                Update: Object.assign(Object.assign({}, updateParams), { UpdateExpression: updateParams.UpdateExpression }),
             },
         ];
         for (const field in previousUniqueFieldValues) {
@@ -358,142 +338,126 @@ export class EntityRepository extends Repository {
                 Put: {
                     TableName: this.TABLE_NAME,
                     ConditionExpression: 'attribute_not_exists(PK)',
-                    Item: {
-                        ...entity.toItem(),
-                        data: {
-                            M: {
-                                ...previousEntity.toItem().data.M,
-                                ...entity.toItem().data.M,
-                            },
-                        },
-                        PK: {
+                    Item: Object.assign(Object.assign({}, entity.toItem()), { data: {
+                            M: Object.assign(Object.assign({}, previousEntity.toItem().data.M), entity.toItem().data.M),
+                        }, PK: {
                             S: `UNIQUE#${field}#${entity.data[field]}`,
-                        },
-                        SK: { S: entity.entityType },
-                        R1PK: entity.keys().PK,
-                        R1SK: entity.keys().SK,
-                    },
+                        }, SK: { S: entity.entityType }, R1PK: entity.keys().PK, R1SK: entity.keys().SK }),
                 },
             });
         }
         return transactItems;
     }
-    async updateEntity(entityType, entityId, toUpdate, opts) {
-        try {
-            const currentDatetime = new Date().toISOString();
-            const toUpdateExpressions = this.toUpdate({
-                updatedAt: currentDatetime,
-                ...toUpdate,
-            });
-            const params = {
-                TableName: this.TABLE_NAME,
-                ReturnValues: 'ALL_NEW',
-                Key: new Entity(entityType, entityId).keys(),
-                ConditionExpression: opts?.ConditionExpression || 'attribute_exists(PK)',
-                UpdateExpression: toUpdateExpressions.UpdateExpression,
-                ExpressionAttributeNames: {
-                    ...toUpdateExpressions.ExpressionAttributeNames,
-                    ...opts?.ExpressionAttributeNames,
-                },
-                ExpressionAttributeValues: {
-                    ...toUpdateExpressions.ExpressionAttributeValues,
-                    ...opts?.ExpressionAttributeValues,
-                },
-            };
-            const entity = new Entity(entityType, entityId, toUpdate.data);
-            const uniqueFields = (this.EntityConfig[entityType].uniqueFields ||
-                []);
-            const hasUniqueFields = Object.keys(toUpdate.data).some((field) => uniqueFields.includes(field));
-            let updatedUniqueFields = [];
-            let previousUniqueFieldValues = {};
-            let previousEntity;
-            if (hasUniqueFields) {
-                previousEntity = await this.getEntity(entityType, entityId);
-                // check if any of the unique fields has changed
-                updatedUniqueFields = uniqueFields.filter((field) => toUpdate.data[field] !==
-                    previousEntity.data[field]);
-                previousUniqueFieldValues = updatedUniqueFields.reduce((acc, field) => ({
-                    ...acc,
-                    [field]: previousEntity.data[field],
-                }), {});
-                for (const field in previousUniqueFieldValues) {
-                    if (typeof toUpdate.data[field] !==
-                        'string') {
-                        throw new StandardError('INVALID_UNIQUE_VALUE_TYPE', `Invalid type. ${field} is not a 'string'.`);
+    updateEntity(entityType, entityId, toUpdate, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const currentDatetime = new Date().toISOString();
+                const toUpdateExpressions = this.toUpdate(Object.assign({ updatedAt: currentDatetime }, toUpdate));
+                const params = {
+                    TableName: this.TABLE_NAME,
+                    ReturnValues: 'ALL_NEW',
+                    Key: new Entity(entityType, entityId).keys(),
+                    ConditionExpression: (opts === null || opts === void 0 ? void 0 : opts.ConditionExpression) || 'attribute_exists(PK)',
+                    UpdateExpression: toUpdateExpressions.UpdateExpression,
+                    ExpressionAttributeNames: Object.assign(Object.assign({}, toUpdateExpressions.ExpressionAttributeNames), opts === null || opts === void 0 ? void 0 : opts.ExpressionAttributeNames),
+                    ExpressionAttributeValues: Object.assign(Object.assign({}, toUpdateExpressions.ExpressionAttributeValues), opts === null || opts === void 0 ? void 0 : opts.ExpressionAttributeValues),
+                };
+                const entity = new Entity(entityType, entityId, toUpdate.data);
+                const uniqueFields = (this.EntityConfig[entityType].uniqueFields ||
+                    []);
+                const hasUniqueFields = Object.keys(toUpdate.data).some((field) => uniqueFields.includes(field));
+                let updatedUniqueFields = [];
+                let previousUniqueFieldValues = {};
+                let previousEntity;
+                if (hasUniqueFields) {
+                    previousEntity = yield this.getEntity(entityType, entityId);
+                    // check if any of the unique fields has changed
+                    updatedUniqueFields = uniqueFields.filter((field) => toUpdate.data[field] !==
+                        previousEntity.data[field]);
+                    previousUniqueFieldValues = updatedUniqueFields.reduce((acc, field) => (Object.assign(Object.assign({}, acc), { [field]: previousEntity.data[field] })), {});
+                    for (const field in previousUniqueFieldValues) {
+                        if (typeof toUpdate.data[field] !==
+                            'string') {
+                            throw new StandardError('INVALID_UNIQUE_VALUE_TYPE', `Invalid type. ${field} is not a 'string'.`);
+                        }
+                    }
+                    if (updatedUniqueFields.length > 0) {
+                        const TransactItems = this.updateEntityTransactItems(entity, params, previousUniqueFieldValues, previousEntity);
+                        yield this.dynamodbClient.transactWriteItems({ TransactItems });
+                        return yield this.getEntity(entityType, entityId);
                     }
                 }
-                if (updatedUniqueFields.length > 0) {
-                    const TransactItems = this.updateEntityTransactItems(entity, params, previousUniqueFieldValues, previousEntity);
-                    await this.dynamodbClient.transactWriteItems({ TransactItems });
-                    return await this.getEntity(entityType, entityId);
+                const resp = yield this.dynamodbClient.updateItem(params);
+                const updatedEntity = Entity.fromItem(resp.Attributes);
+                return updatedEntity;
+            }
+            catch (err) {
+                if (err instanceof ConditionalCheckFailedException) {
+                    throw new StandardError('ENTITY_NOT_FOUND', 'Entity not found', err, {
+                        entityId,
+                        toUpdate,
+                    });
                 }
+                throw err;
             }
-            const resp = await this.dynamodbClient.updateItem(params);
-            const updatedEntity = Entity.fromItem(resp.Attributes);
-            return updatedEntity;
-        }
-        catch (err) {
-            if (err instanceof ConditionalCheckFailedException) {
-                throw new StandardError('ENTITY_NOT_FOUND', 'Entity not found', err, {
-                    entityId,
-                    toUpdate,
+        });
+    }
+    deleteEntity(entityType, entityId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const entity = new Entity(entityType, entityId);
+                yield this.dynamodbClient.deleteItem({
+                    TableName: this.TABLE_NAME,
+                    Key: entity.keys(),
+                    ConditionExpression: 'attribute_exists(PK)',
                 });
             }
-            throw err;
-        }
+            catch (err) {
+                if (err instanceof ConditionalCheckFailedException) {
+                    throw new StandardError('ENTITY_NOT_FOUND', 'Entity not found', err, {
+                        entityId,
+                    });
+                }
+                throw err;
+            }
+        });
     }
-    async deleteEntity(entityType, entityId) {
-        try {
-            const entity = new Entity(entityType, entityId);
-            await this.dynamodbClient.deleteItem({
-                TableName: this.TABLE_NAME,
-                Key: entity.keys(),
-                ConditionExpression: 'attribute_exists(PK)',
+    queryEntities(entityType, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = {
+                items: [],
+                totalCount: 0,
+            };
+            // let regex be empty if its invalid (eg. +)
+            let queryRegex = /(?:)/;
+            try {
+                queryRegex = new RegExp(query.toLowerCase());
+            }
+            catch (err) {
+                return results;
+            }
+            const listResults = yield this.listEntities({
+                entityType,
             });
-        }
-        catch (err) {
-            if (err instanceof ConditionalCheckFailedException) {
-                throw new StandardError('ENTITY_NOT_FOUND', 'Entity not found', err, {
-                    entityId,
-                });
+            results.items.push(...listResults.items);
+            results.totalCount += listResults.totalCount || 0;
+            const filteredItems = [];
+            const { searchableFields } = this.EntityConfig[entityType];
+            for (const item of results.items) {
+                const searchTerm = (searchableFields !== null && searchableFields !== void 0 ? searchableFields : [])
+                    .map((field) => { var _a; return (_a = item.data[field]) === null || _a === void 0 ? void 0 : _a.toLowerCase(); })
+                    .join(' ');
+                const isMatched = queryRegex.test(searchTerm);
+                if (isMatched) {
+                    filteredItems.push(item);
+                }
             }
-            throw err;
-        }
-    }
-    async queryEntities(entityType, query) {
-        const results = {
-            items: [],
-            totalCount: 0,
-        };
-        // let regex be empty if its invalid (eg. +)
-        let queryRegex = /(?:)/;
-        try {
-            queryRegex = new RegExp(query.toLowerCase());
-        }
-        catch (err) {
-            return results;
-        }
-        const listResults = await this.listEntities({
-            entityType,
+            return {
+                items: filteredItems,
+                totalCount: results.totalCount,
+                filteredCount: filteredItems.length,
+            };
         });
-        results.items.push(...listResults.items);
-        results.totalCount += listResults.totalCount || 0;
-        const filteredItems = [];
-        const { searchableFields } = this.EntityConfig[entityType];
-        for (const item of results.items) {
-            const searchTerm = (searchableFields ?? [])
-                .map((field) => item.data[field]?.toLowerCase())
-                .join(' ');
-            const isMatched = queryRegex.test(searchTerm);
-            if (isMatched) {
-                filteredItems.push(item);
-            }
-        }
-        return {
-            items: filteredItems,
-            totalCount: results.totalCount,
-            filteredCount: filteredItems.length,
-        };
     }
 }
 //# sourceMappingURL=Entity.js.map