@monorise/core 1.0.4-7 → 3.0.1

package/dist/data/Entity.js

@@ -1,16 +1,21 @@
-import { ConditionalCheckFailedException, } from '@aws-sdk/client-dynamodb';
+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 { BatchStatementErrorCodeEnum, ConditionalCheckFailedException, TransactionCanceledException, } from '@aws-sdk/client-dynamodb';
 import { marshall, unmarshall } from '@aws-sdk/util-dynamodb';
 import { ulid } from 'ulid';
-import { StandardError } from '../errors/standard-error';
+import { StandardError, StandardErrorCode } from '../errors/standard-error';
+import { fromLastKeyQuery } from '../helpers/fromLastKeyQuery';
+import { toLastKeyResponse } from '../helpers/toLastKeyResponse';
 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;
@@ -22,7 +27,7 @@ export class Entity extends Item {
     }
     static fromItem(item) {
         if (!item)
-            throw new StandardError('ENTITY_IS_UNDEFINED', 'Entity item empty');
+            throw new StandardError(StandardErrorCode.ENTITY_IS_UNDEFINED, 'Entity item empty');
         const parsedItem = unmarshall(item);
         return new Entity(parsedItem.entityType, parsedItem.entityId, parsedItem.data, parsedItem.createdAt ? new Date(parsedItem.createdAt) : undefined, parsedItem.updatedAt ? new Date(parsedItem.updatedAt) : undefined);
     }
@@ -46,16 +51,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 +72,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,114 +79,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: fromLastKeyQuery(lastKey),
+                })));
+                items = items.concat((_b = resp.Items) !== null && _b !== void 0 ? _b : []);
+                lastKey = toLastKeyResponse(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(StandardErrorCode.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 },
-            },
+    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 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 },
-            },
+    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(StandardErrorCode.UNIQUE_VALUE_EXISTS, `${fieldName} '${value}' already exists`);
+            }
+            return;
         });
-        if (resp.Items?.[0]) {
-            throw new StandardError('EMAIL_EXISTS', 'Email already exists');
-        }
-        return;
     }
     createEntityTransactItems(entity, opts) {
         const TransactItems = [
@@ -194,26 +234,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 } }),
                 },
             },
         ];
@@ -226,136 +257,248 @@ 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 }),
+                },
+            });
+        }
+        for (const field in opts.uniqueFieldValues || {}) {
+            TransactItems.push({
+                Put: {
+                    TableName: this.TABLE_NAME,
+                    ConditionExpression: 'attribute_not_exists(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, createdAt: { S: entity.createdAt || new Date().toISOString() }, updatedAt: { S: entity.updatedAt || new Date().toISOString() } }),
                 },
             });
         }
         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 TransactItems = this.createEntityTransactItems(entity, {
-            mutualId: opts?.mutualId,
-        });
-        await this.dynamodbClient.transactWriteItems({ TransactItems });
-        return entity;
-    }
-    async upsertEntity(entityType, entityId, payload) {
-        const toUpdateExpressions = this.toUpdate({
-            entityType,
-            entityId,
-            data: payload,
+    createEntity(entityType, entityPayload, entityId, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            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 uniqueFieldValues = {};
+            for (const field of uniqueFields) {
+                if (!(field in entityPayload))
+                    continue;
+                if (typeof entityPayload[field] !== 'string') {
+                    throw new StandardError(StandardErrorCode.INVALID_UNIQUE_VALUE_TYPE, `Invalid type. ${field} is not a 'string'.`);
+                }
+                uniqueFieldValues[field] = entityPayload[field];
+            }
+            const TransactItems = this.createEntityTransactItems(entity, {
+                mutualId: opts === null || opts === void 0 ? void 0 : opts.mutualId,
+                uniqueFieldValues,
+            });
+            try {
+                yield this.dynamodbClient.transactWriteItems({ TransactItems });
+            }
+            catch (err) {
+                if (err instanceof TransactionCanceledException) {
+                    let idxUniqueFieldErr = 2;
+                    if (this.EmailAuthEnabledEntities.includes(entity.entityType)) {
+                        idxUniqueFieldErr += 1;
+                    }
+                    const uniqueFieldErr = ((_b = err.CancellationReasons) === null || _b === void 0 ? void 0 : _b.slice(idxUniqueFieldErr)) || [];
+                    for (let i = 0; i < uniqueFieldErr.length; i++) {
+                        if (uniqueFieldErr[i].Code ===
+                            BatchStatementErrorCodeEnum.ConditionalCheckFailed) {
+                            const field = uniqueFields[i];
+                            throw new StandardError(StandardErrorCode.UNIQUE_VALUE_EXISTS, `${field} '${uniqueFieldValues[field]}' already exists`);
+                        }
+                    }
+                }
+                throw err;
+            }
+            return entity;
         });
-        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;
     }
-    async updateEntity(entityType, entityId, toUpdate, opts) {
-        try {
+    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,
-                ...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,
-                },
+                ExpressionAttributeNames: Object.assign({}, toUpdateExpressions.ExpressionAttributeNames),
+                ExpressionAttributeValues: Object.assign({}, toUpdateExpressions.ExpressionAttributeValues),
             };
-            const resp = await this.dynamodbClient.updateItem(params);
+            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;
-        }
+        });
     }
-    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)',
+    updateEntityTransactItems(entity, updateParams, previousUniqueFieldValues, previousEntity) {
+        const transactItems = [
+            {
+                Update: Object.assign(Object.assign({}, updateParams), { UpdateExpression: updateParams.UpdateExpression }),
+            },
+        ];
+        for (const field in previousUniqueFieldValues) {
+            transactItems.push({
+                Delete: {
+                    TableName: this.TABLE_NAME,
+                    Key: {
+                        PK: { S: `UNIQUE#${field}#${previousUniqueFieldValues[field]}` },
+                        SK: { S: entity.entityType },
+                    },
+                },
+            }, {
+                Put: {
+                    TableName: this.TABLE_NAME,
+                    ConditionExpression: 'attribute_not_exists(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, createdAt: {
+                            S: previousEntity.createdAt ||
+                                entity.createdAt ||
+                                new Date().toISOString(),
+                        }, updatedAt: { S: entity.updatedAt || new Date().toISOString() } }),
+                },
             });
         }
-        catch (err) {
-            if (err instanceof ConditionalCheckFailedException) {
-                throw new StandardError('ENTITY_NOT_FOUND', 'Entity not found', err, {
-                    entityId,
-                });
+        return transactItems;
+    }
+    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] !== undefined &&
+                        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(StandardErrorCode.INVALID_UNIQUE_VALUE_TYPE, `Invalid type. ${field} is not a 'string'.`);
+                        }
+                    }
+                    if (updatedUniqueFields.length > 0) {
+                        const TransactItems = this.updateEntityTransactItems(entity, params, previousUniqueFieldValues, previousEntity);
+                        try {
+                            yield this.dynamodbClient.transactWriteItems({ TransactItems });
+                        }
+                        catch (err) {
+                            if (err instanceof TransactionCanceledException) {
+                                const [updateErr, ...uniqueFieldErr] = err.CancellationReasons || [];
+                                for (let i = 0; i < uniqueFieldErr.length; i++) {
+                                    if (i % 2 === 1 &&
+                                        uniqueFieldErr[i].Code ===
+                                            BatchStatementErrorCodeEnum.ConditionalCheckFailed) {
+                                        const field = updatedUniqueFields[Math.floor(i / 2)];
+                                        throw new StandardError(StandardErrorCode.UNIQUE_VALUE_EXISTS, `${field} '${entity.data[field]}' already exists`);
+                                    }
+                                }
+                            }
+                            throw err;
+                        }
+                        return yield this.getEntity(entityType, entityId);
+                    }
+                }
+                const resp = yield this.dynamodbClient.updateItem(params);
+                const updatedEntity = Entity.fromItem(resp.Attributes);
+                return updatedEntity;
             }
-            throw err;
-        }
+            catch (err) {
+                if (err instanceof ConditionalCheckFailedException) {
+                    throw new StandardError(StandardErrorCode.ENTITY_NOT_FOUND, 'Entity not found', err, {
+                        entityId,
+                        toUpdate,
+                    });
+                }
+                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,
+    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)',
+                });
+            }
+            catch (err) {
+                if (err instanceof ConditionalCheckFailedException) {
+                    throw new StandardError(StandardErrorCode.ENTITY_NOT_FOUND, 'Entity not found', err, {
+                        entityId,
+                    });
+                }
+                throw err;
+            }
         });
-        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);
+    }
+    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());
             }
-        }
-        return {
-            items: filteredItems,
-            totalCount: results.totalCount,
-            filteredCount: filteredItems.length,
-        };
+            catch (err) {
+                return results;
+            }
+            const listResults = yield this.listEntities({
+                entityType,
+            });
+            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);
+                }
+            }
+            return {
+                items: filteredItems,
+                totalCount: results.totalCount,
+                filteredCount: filteredItems.length,
+            };
+        });
     }
 }
 //# sourceMappingURL=Entity.js.map