@monorise/core 1.0.4-7 → 3.0.1

package/dist/data/Mutual.js

@@ -1,23 +1,22 @@
+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, 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 { sleep } from '../helpers/sleep';
+import { toLastKeyResponse } from '../helpers/toLastKeyResponse';
 import { PROJECTION_EXPRESSION, } from './ProjectionExpression';
 import { Repository } from './abstract/Repository.base';
 export class Mutual {
-    byEntityType;
-    byEntityId;
-    byData;
-    entityType;
-    entityId;
-    data;
-    mutualData;
-    mutualId;
-    _createdAt;
-    _updatedAt;
-    _mutualUpdatedAt;
-    _expiresAt;
     constructor(byEntityType, byEntityId, byData, entityType, entityId, data, mutualData, mutualId, _createdAt, _updatedAt, _mutualUpdatedAt, _expiresAt) {
         this.byEntityType = byEntityType;
         this.byEntityId = byEntityId;
@@ -34,7 +33,7 @@ export class Mutual {
     }
     static fromItem(item) {
         if (!item)
-            throw new StandardError('MUTUAL_IS_UNDEFINED', 'Mutual item empty');
+            throw new StandardError(StandardErrorCode.MUTUAL_IS_UNDEFINED, 'Mutual item empty');
         const parsedItem = unmarshall(item);
         return new Mutual(parsedItem.byEntityType, parsedItem.byEntityId, parsedItem.byData, parsedItem.entityType, parsedItem.entityId, parsedItem.data, parsedItem.mutualData, parsedItem.mutualId, parsedItem.createdAt ? new Date(parsedItem.createdAt) : undefined, parsedItem.updatedAt ? new Date(parsedItem.updatedAt) : undefined, parsedItem.mutualUpdatedAt
             ? new Date(parsedItem.mutualUpdatedAt)
@@ -68,44 +67,28 @@ export class Mutual {
         return '#METADATA#';
     }
     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();
     }
     get mutualUpdatedAt() {
-        return this._mutualUpdatedAt?.toISOString();
+        var _a;
+        return (_a = this._mutualUpdatedAt) === null || _a === void 0 ? void 0 : _a.toISOString();
     }
     get expiresAt() {
-        return this._expiresAt?.toISOString();
-    }
-    toMutualItemOnly() {
-        // Mutual #METADATA# has `mutualData` only
-        return {
-            ...marshall({ ...this.toJSON(), data: {} }, { removeUndefinedValues: true }),
-            ...this.mainKeys(),
-        };
+        var _a;
+        return (_a = this._expiresAt) === null || _a === void 0 ? void 0 : _a.toISOString();
     }
     toItem() {
-        return {
-            ...marshall(this.toJSON(), { removeUndefinedValues: true }),
-            ...this.mainKeys(),
-        };
+        return Object.assign(Object.assign({}, marshall(this.toJSON(), { removeUndefinedValues: true })), this.mainKeys());
     }
     toReversedItem() {
         const item = this.toJSON();
-        const reversedMutual = {
-            ...item,
-            byEntityType: item.entityType,
-            byEntityId: item.entityId,
-            entityType: item.byEntityType,
-            entityId: item.byEntityId,
-            data: this.byData,
-        };
-        return {
-            ...marshall(reversedMutual, { removeUndefinedValues: true }),
-            ...this.mainKeys(),
-        };
+        const reversedMutual = Object.assign(Object.assign({}, item), { byEntityType: item.entityType, byEntityId: item.entityId, entityType: item.byEntityType, entityId: item.byEntityId, data: this.byData });
+        return Object.assign(Object.assign({}, marshall(reversedMutual, { removeUndefinedValues: true })), this.mainKeys());
     }
     toJSON() {
         return {
@@ -124,369 +107,334 @@ export class Mutual {
     }
 }
 export class MutualRepository extends Repository {
-    TABLE_NAME;
-    dynamodbClient;
-    ddbUtils;
     constructor(TABLE_NAME, dynamodbClient, ddbUtils) {
         super();
         this.TABLE_NAME = TABLE_NAME;
         this.dynamodbClient = dynamodbClient;
         this.ddbUtils = ddbUtils;
     }
-    async listEntitiesByEntity(byEntityType, byEntityId, entityType, opts = {}) {
-        const mutual = new Mutual(byEntityType, byEntityId, {}, entityType, 'list_by_only', {}, {});
-        const listAssociationsQuery = {
-            TableName: this.TABLE_NAME,
-            KeyConditionExpression: '#PK = :PK and begins_with(#SK, :SK)',
-            FilterExpression: 'attribute_not_exists(#expiresAt) or attribute_type(#expiresAt, :nullType)',
-            ExpressionAttributeNames: {
-                '#PK': 'PK',
-                '#SK': 'SK',
-                '#expiresAt': 'expiresAt',
-            },
-            ExpressionAttributeValues: {
-                ':PK': {
-                    S: mutual.byFullEntityId,
+    listEntitiesByEntity(byEntityType_1, byEntityId_1, entityType_1) {
+        return __awaiter(this, arguments, void 0, function* (byEntityType, byEntityId, entityType, opts = {}) {
+            var _a, _b, _c, _d;
+            const mutual = new Mutual(byEntityType, byEntityId, {}, entityType, 'list_by_only', {}, {});
+            const listAssociationsQuery = {
+                TableName: this.TABLE_NAME,
+                KeyConditionExpression: '#PK = :PK and begins_with(#SK, :SK)',
+                FilterExpression: 'attribute_not_exists(#expiresAt) or attribute_type(#expiresAt, :nullType)',
+                ExpressionAttributeNames: {
+                    '#PK': 'PK',
+                    '#SK': 'SK',
+                    '#expiresAt': 'expiresAt',
                 },
-                ':SK': {
-                    S: mutual.listEntitySK,
+                ExpressionAttributeValues: {
+                    ':PK': {
+                        S: mutual.byFullEntityId,
+                    },
+                    ':SK': {
+                        S: `${mutual.listEntitySK}#`,
+                    },
+                    ':nullType': { S: 'NULL' },
                 },
-                ':nullType': { S: 'NULL' },
-            },
-            ProjectionExpression: opts.ProjectionExpression,
-        };
-        let lastKey = opts.lastKey;
-        let items = [];
-        let remainingCount = opts.limit ?? 0;
-        do {
-            const resp = await this.dynamodbClient.query({
-                ...listAssociationsQuery,
-                ...(remainingCount && { Limit: remainingCount }),
-                ...(lastKey && {
-                    ExclusiveStartKey: lastKey,
-                }),
+                ProjectionExpression: opts.ProjectionExpression,
+                ScanIndexForward: false,
+            };
+            let lastKey = opts.lastKey;
+            let items = [];
+            let remainingCount = (_a = opts.limit) !== null && _a !== void 0 ? _a : 0;
+            do {
+                const resp = yield this.dynamodbClient.query(Object.assign(Object.assign(Object.assign({}, listAssociationsQuery), (remainingCount && { Limit: remainingCount })), (lastKey && {
+                    ExclusiveStartKey: fromLastKeyQuery(lastKey),
+                })));
+                items = items.concat(((_b = resp.Items) === null || _b === void 0 ? void 0 : _b.map((item) => Mutual.fromItem(item))) || []);
+                lastKey = toLastKeyResponse(resp.LastEvaluatedKey);
+                if (opts.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
+            (opts.limit && remainingCount && lastKey) ||
+                // no limit is given and there are still items to retrieve
+                (!opts.limit && lastKey));
+            return {
+                items,
+                lastKey,
+            };
+        });
+    }
+    getMutual(byEntityType, byEntityId, entityType, entityId, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const mutual = new Mutual(byEntityType, byEntityId, {}, entityType, entityId, {}, {});
+            const resp = yield this.dynamodbClient.query({
+                TableName: this.TABLE_NAME,
+                KeyConditionExpression: '#PK = :PK and begins_with(#SK, :SK)',
+                FilterExpression: 'attribute_not_exists(#expiresAt) or attribute_type(#expiresAt, :nullType)',
+                ExpressionAttributeNames: {
+                    '#PK': 'PK',
+                    '#SK': 'SK',
+                    '#expiresAt': 'expiresAt',
+                },
+                ExpressionAttributeValues: {
+                    ':PK': { S: mutual.byFullEntityId },
+                    ':SK': { S: mutual.fullEntityId },
+                    ':nullType': { S: 'NULL' },
+                },
+                Limit: 1,
             });
-            items = items.concat(resp.Items?.map((item) => Mutual.fromItem(item)) || []);
-            lastKey = resp.LastEvaluatedKey;
-            if (opts.limit) {
-                remainingCount = remainingCount - (resp.Items?.length ?? 0);
+            let mutualMetadata = null;
+            if (opts === null || opts === void 0 ? void 0 : opts.isFromMetadata) {
+                const tempMutual = Mutual.fromItem((_a = resp.Items) === null || _a === void 0 ? void 0 : _a[0]);
+                const respMetadataMutual = yield this.dynamodbClient.getItem({
+                    TableName: this.TABLE_NAME,
+                    Key: tempMutual.mainKeys(),
+                    ProjectionExpression: opts === null || opts === void 0 ? void 0 : opts.ProjectionExpression,
+                });
+                mutualMetadata = Mutual.fromItem(respMetadataMutual.Item);
             }
-        } while (
-        // limit is given, haven't reach limit, and there are still items to retrieve
-        (opts.limit && remainingCount && lastKey) ||
-            // no limit is given and there are still items to retrieve
-            (!opts.limit && lastKey));
-        return {
-            items,
-            lastKey,
-        };
-    }
-    async getMutual(byEntityType, byEntityId, entityType, entityId, opts) {
-        const mutual = new Mutual(byEntityType, byEntityId, {}, entityType, entityId, {}, {});
-        const resp = await this.dynamodbClient.getItem({
-            TableName: this.TABLE_NAME,
-            Key: mutual.subKeys(),
-            ProjectionExpression: opts?.ProjectionExpression,
+            return mutualMetadata || Mutual.fromItem((_b = resp.Items) === null || _b === void 0 ? void 0 : _b[0]);
         });
-        let mutualMetadata = null;
-        if (opts?.isFromMetadata) {
-            const tempMutual = Mutual.fromItem(resp.Item);
-            const respMetadataMutual = await this.dynamodbClient.getItem({
+    }
+    checkMutualExist(byEntityType, byEntityId, entityType, entityId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const mutual = new Mutual(byEntityType, byEntityId, {}, entityType, entityId, {}, {});
+            const resp = yield this.dynamodbClient.getItem({
                 TableName: this.TABLE_NAME,
-                Key: tempMutual.mainKeys(),
-                ProjectionExpression: opts?.ProjectionExpression,
+                Key: mutual.subKeys(),
+                ProjectionExpression: 'PK, SK, expiresAt',
             });
-            mutualMetadata = Mutual.fromItem(respMetadataMutual.Item);
-        }
-        return mutualMetadata || Mutual.fromItem(resp.Item);
-    }
-    async checkMutualExist(byEntityType, byEntityId, entityType, entityId) {
-        const mutual = new Mutual(byEntityType, byEntityId, {}, entityType, entityId, {}, {});
-        const resp = await this.dynamodbClient.getItem({
-            TableName: this.TABLE_NAME,
-            Key: mutual.subKeys(),
-            ProjectionExpression: 'PK, SK, expiresAt',
+            if (resp.Item && !((_a = resp.Item) === null || _a === void 0 ? void 0 : _a.expiresAt)) {
+                throw new StandardError(StandardErrorCode.MUTUAL_EXISTS, 'Entities are already linked');
+            }
+            return;
         });
-        if (resp.Item && !resp.Item?.expiresAt) {
-            throw new StandardError('MUTUAL_EXISTS', 'Entities are already linked');
-        }
-        return;
     }
     createMutualTransactItems(mutual, opts) {
         const TransactItems = [
             {
                 Put: {
                     TableName: this.TABLE_NAME,
-                    ConditionExpression: opts?.ConditionExpression ||
+                    ConditionExpression: (opts === null || opts === void 0 ? void 0 : opts.ConditionExpression) ||
                         'attribute_not_exists(PK) OR attribute_exists(expiresAt)',
-                    ExpressionAttributeNames: opts?.ExpressionAttributeNames,
-                    ExpressionAttributeValues: opts?.ExpressionAttributeValues,
+                    ExpressionAttributeNames: opts === null || opts === void 0 ? void 0 : opts.ExpressionAttributeNames,
+                    ExpressionAttributeValues: opts === null || opts === void 0 ? void 0 : opts.ExpressionAttributeValues,
                     Item: mutual.toItem(),
                 },
             },
             {
                 Put: {
                     TableName: this.TABLE_NAME,
-                    ConditionExpression: opts?.ConditionExpression ||
+                    ConditionExpression: (opts === null || opts === void 0 ? void 0 : opts.ConditionExpression) ||
                         'attribute_not_exists(PK) OR attribute_exists(expiresAt)',
-                    ExpressionAttributeNames: opts?.ExpressionAttributeNames,
-                    ExpressionAttributeValues: opts?.ExpressionAttributeValues,
-                    Item: {
-                        ...mutual.toItem(),
-                        PK: { S: mutual.byFullEntityId },
-                        SK: { S: mutual.fullEntityId },
-                        R1PK: { S: mutual.fullEntityId },
-                        R1SK: { S: mutual.byFullEntityId },
-                        R2PK: { S: mutual.mainPk },
-                        R2SK: { S: mutual.byFullEntityId },
-                    },
+                    ExpressionAttributeNames: opts === null || opts === void 0 ? void 0 : opts.ExpressionAttributeNames,
+                    ExpressionAttributeValues: opts === null || opts === void 0 ? void 0 : opts.ExpressionAttributeValues,
+                    Item: Object.assign(Object.assign({}, mutual.toItem()), { PK: { S: mutual.byFullEntityId }, SK: { S: mutual.fullEntityId }, R1PK: { S: mutual.fullEntityId }, R1SK: { S: mutual.byFullEntityId }, R2PK: { S: mutual.mainPk }, R2SK: { S: mutual.byFullEntityId } }),
                 },
             },
             {
                 Put: {
                     TableName: this.TABLE_NAME,
-                    ConditionExpression: opts?.ConditionExpression ||
+                    ConditionExpression: (opts === null || opts === void 0 ? void 0 : opts.ConditionExpression) ||
                         'attribute_not_exists(PK) OR attribute_exists(expiresAt)',
-                    ExpressionAttributeNames: opts?.ExpressionAttributeNames,
-                    ExpressionAttributeValues: opts?.ExpressionAttributeValues,
-                    Item: {
-                        ...mutual.toReversedItem(),
-                        PK: { S: mutual.fullEntityId },
-                        SK: { S: mutual.byFullEntityId },
-                        R1PK: { S: mutual.byFullEntityId },
-                        R1SK: { S: mutual.fullEntityId },
-                        R2PK: { S: mutual.mainPk },
-                        R2SK: { S: mutual.fullEntityId },
-                    },
+                    ExpressionAttributeNames: opts === null || opts === void 0 ? void 0 : opts.ExpressionAttributeNames,
+                    ExpressionAttributeValues: opts === null || opts === void 0 ? void 0 : opts.ExpressionAttributeValues,
+                    Item: Object.assign(Object.assign({}, mutual.toReversedItem()), { PK: { S: mutual.fullEntityId }, SK: { S: mutual.byFullEntityId }, R1PK: { S: mutual.byFullEntityId }, R1SK: { S: mutual.fullEntityId }, R2PK: { S: mutual.mainPk }, R2SK: { S: mutual.fullEntityId } }),
                 },
             },
         ];
         return TransactItems;
     }
-    async createMutual(byEntityType, byEntityId, byData, entityType, entityId, data, mutualData = {}, opts) {
-        const errorContext = {};
-        const currentDatetime = opts?.createAndUpdateDatetime || new Date();
-        const mutual = new Mutual(byEntityType, byEntityId, byData, entityType, entityId, data, mutualData, ulid(), currentDatetime, currentDatetime, currentDatetime);
-        const TransactItems = this.createMutualTransactItems(mutual, {
-            ConditionExpression: opts?.ConditionExpression,
-            ExpressionAttributeNames: opts?.ExpressionAttributeNames,
-            ExpressionAttributeValues: opts?.ExpressionAttributeValues,
+    createMutual(byEntityType_1, byEntityId_1, byData_1, entityType_1, entityId_1, data_1) {
+        return __awaiter(this, arguments, void 0, function* (byEntityType, byEntityId, byData, entityType, entityId, data, mutualData = {}, opts) {
+            const errorContext = {};
+            const currentDatetime = (opts === null || opts === void 0 ? void 0 : opts.createAndUpdateDatetime) || new Date();
+            const mutual = new Mutual(byEntityType, byEntityId, byData, entityType, entityId, data, mutualData, ulid(), currentDatetime, currentDatetime, currentDatetime);
+            const TransactItems = this.createMutualTransactItems(mutual, {
+                ConditionExpression: opts === null || opts === void 0 ? void 0 : opts.ConditionExpression,
+                ExpressionAttributeNames: opts === null || opts === void 0 ? void 0 : opts.ExpressionAttributeNames,
+                ExpressionAttributeValues: opts === null || opts === void 0 ? void 0 : opts.ExpressionAttributeValues,
+            });
+            errorContext.TransactItems = TransactItems;
+            yield this.dynamodbClient.transactWriteItems({ TransactItems });
+            return mutual;
         });
-        errorContext.TransactItems = TransactItems;
-        await this.dynamodbClient.transactWriteItems({ TransactItems });
-        return mutual;
     }
-    async updateMutual(byEntityType, byEntityId, entityType, entityId, toUpdate, opts) {
-        const returnUpdatedValue = opts?.returnUpdatedValue ?? false;
-        const errorContext = {};
-        try {
-            const mutual = await this.getMutual(byEntityType, byEntityId, entityType, entityId, { ProjectionExpression: PROJECTION_EXPRESSION.NO_DATA });
-            const currentDatetime = new Date().toISOString();
-            const toUpdateExpressions = this.toUpdate({
-                mutualUpdatedAt: currentDatetime,
-                ...toUpdate,
-            }, { maxLevel: opts?.maxObjectUpdateLevel });
-            const updateExpression = {
-                ConditionExpression: opts?.ConditionExpression || 'attribute_exists(PK)',
-                UpdateExpression: toUpdateExpressions.UpdateExpression,
-                ExpressionAttributeNames: {
-                    ...toUpdateExpressions.ExpressionAttributeNames,
-                    ...opts?.ExpressionAttributeNames,
-                },
-                ExpressionAttributeValues: {
-                    ...toUpdateExpressions.ExpressionAttributeValues,
-                    ...opts?.ExpressionAttributeValues,
-                },
-            };
-            const TransactItems = [
-                {
-                    Update: {
-                        TableName: this.TABLE_NAME,
-                        Key: mutual.mainKeys(),
-                        ...updateExpression,
+    updateMutual(byEntityType, byEntityId, entityType, entityId, toUpdate, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const returnUpdatedValue = (_a = opts === null || opts === void 0 ? void 0 : opts.returnUpdatedValue) !== null && _a !== void 0 ? _a : false;
+            const errorContext = {};
+            try {
+                const mutual = yield this.getMutual(byEntityType, byEntityId, entityType, entityId, { ProjectionExpression: PROJECTION_EXPRESSION.NO_DATA });
+                const currentDatetime = new Date().toISOString();
+                const toUpdateExpressions = this.toUpdate(Object.assign({ mutualUpdatedAt: currentDatetime }, toUpdate), { maxLevel: opts === null || opts === void 0 ? void 0 : opts.maxObjectUpdateLevel });
+                const updateExpression = {
+                    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 TransactItems = [
+                    {
+                        Update: Object.assign({ TableName: this.TABLE_NAME, Key: mutual.mainKeys() }, updateExpression),
                     },
-                },
-                {
-                    Update: {
-                        TableName: this.TABLE_NAME,
-                        Key: {
-                            PK: { S: mutual.byFullEntityId },
-                            SK: { S: mutual.fullEntityId },
-                        },
-                        ...updateExpression,
+                    {
+                        Update: Object.assign({ TableName: this.TABLE_NAME, Key: {
+                                PK: { S: mutual.byFullEntityId },
+                                SK: { S: mutual.fullEntityId },
+                            } }, updateExpression),
                     },
-                },
-                {
-                    Update: {
-                        TableName: this.TABLE_NAME,
-                        Key: {
-                            PK: { S: mutual.fullEntityId },
-                            SK: { S: mutual.byFullEntityId },
-                        },
-                        ...updateExpression,
+                    {
+                        Update: Object.assign({ TableName: this.TABLE_NAME, Key: {
+                                PK: { S: mutual.fullEntityId },
+                                SK: { S: mutual.byFullEntityId },
+                            } }, updateExpression),
                     },
-                },
-            ];
-            errorContext.TransactItems = TransactItems;
-            await this.ddbUtils.executeTransactWrite({ TransactItems });
-            if (!returnUpdatedValue) {
-                return;
+                ];
+                errorContext.TransactItems = TransactItems;
+                yield this.ddbUtils.executeTransactWrite({ TransactItems });
+                if (!returnUpdatedValue) {
+                    return;
+                }
+                const updatedMutual = yield this.getMutual(byEntityType, byEntityId, entityType, entityId);
+                return updatedMutual;
             }
-            const updatedMutual = await this.getMutual(byEntityType, byEntityId, entityType, entityId);
-            return updatedMutual;
-        }
-        catch (err) {
-            if (err instanceof StandardError &&
-                err.code === 'CONDITIONAL_CHECK_FAILED') {
-                throw new StandardError('MUTUAL_NOT_FOUND', 'Mutual not found', err, {
-                    errorContext,
-                });
+            catch (err) {
+                if (err instanceof StandardError &&
+                    err.code === StandardErrorCode.CONDITIONAL_CHECK_FAILED) {
+                    throw new StandardError(StandardErrorCode.MUTUAL_NOT_FOUND, 'Mutual not found', err, {
+                        errorContext,
+                    });
+                }
+                throw err;
             }
-            throw err;
-        }
+        });
     }
-    async deleteMutual(byEntityType, byEntityId, entityType, entityId, opts) {
-        const errorContext = {
-            byEntityType,
-            byEntityId,
-            entityType,
-            entityId,
-        };
-        try {
-            const mutual = await this.getMutual(byEntityType, byEntityId, entityType, entityId, { ProjectionExpression: PROJECTION_EXPRESSION.NO_DATA });
-            const tenMinsLater = Math.floor(new Date().getTime() / 1000 + 10 * 60);
-            const expressions = {
-                UpdateExpression: 'SET #expiresAt = :expiresAt, #mutualUpdatedAt = :mutualUpdatedAt, #updatedAt = :mutualUpdatedAt',
-                ConditionExpression: opts?.ConditionExpression ||
-                    'attribute_exists(PK) AND attribute_not_exists(#expiresAt)',
-                ExpressionAttributeNames: {
-                    '#expiresAt': 'expiresAt',
-                    '#mutualUpdatedAt': 'mutualUpdatedAt',
-                    '#updatedAt': 'updatedAt',
-                    ...opts?.ExpressionAttributeNames,
-                },
-                ExpressionAttributeValues: {
-                    ':expiresAt': { N: String(tenMinsLater) },
-                    ':mutualUpdatedAt': { S: new Date().toISOString() },
-                    ...opts?.ExpressionAttributeValues,
-                },
+    deleteMutual(byEntityType, byEntityId, entityType, entityId, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const errorContext = {
+                byEntityType,
+                byEntityId,
+                entityType,
+                entityId,
             };
-            const TransactItems = [
-                {
-                    Update: {
-                        TableName: this.TABLE_NAME,
-                        Key: mutual.mainKeys(),
-                        ...expressions,
+            try {
+                const mutual = yield this.getMutual(byEntityType, byEntityId, entityType, entityId, { ProjectionExpression: PROJECTION_EXPRESSION.NO_DATA });
+                const tenMinsLater = Math.floor(new Date().getTime() / 1000 + 10 * 60);
+                const expressions = {
+                    UpdateExpression: 'SET #expiresAt = :expiresAt, #mutualUpdatedAt = :mutualUpdatedAt, #updatedAt = :mutualUpdatedAt',
+                    ConditionExpression: (opts === null || opts === void 0 ? void 0 : opts.ConditionExpression) ||
+                        'attribute_exists(PK) AND attribute_not_exists(#expiresAt)',
+                    ExpressionAttributeNames: Object.assign({ '#expiresAt': 'expiresAt', '#mutualUpdatedAt': 'mutualUpdatedAt', '#updatedAt': 'updatedAt' }, opts === null || opts === void 0 ? void 0 : opts.ExpressionAttributeNames),
+                    ExpressionAttributeValues: Object.assign({ ':expiresAt': { N: String(tenMinsLater) }, ':mutualUpdatedAt': { S: new Date().toISOString() } }, opts === null || opts === void 0 ? void 0 : opts.ExpressionAttributeValues),
+                };
+                const TransactItems = [
+                    {
+                        Update: Object.assign({ TableName: this.TABLE_NAME, Key: mutual.mainKeys() }, expressions),
                     },
-                },
-                {
-                    Update: {
-                        TableName: this.TABLE_NAME,
-                        Key: {
-                            PK: { S: mutual.byFullEntityId },
-                            SK: { S: mutual.fullEntityId },
-                        },
-                        ...expressions,
+                    {
+                        Update: Object.assign({ TableName: this.TABLE_NAME, Key: {
+                                PK: { S: mutual.byFullEntityId },
+                                SK: { S: mutual.fullEntityId },
+                            } }, expressions),
                     },
+                    {
+                        Update: Object.assign({ TableName: this.TABLE_NAME, Key: {
+                                PK: { S: mutual.fullEntityId },
+                                SK: { S: mutual.byFullEntityId },
+                            } }, expressions),
+                    },
+                ];
+                errorContext.TransactItems = TransactItems;
+                yield this.dynamodbClient.transactWriteItems({ TransactItems });
+                return mutual;
+            }
+            catch (err) {
+                const isConditionalCheckFailed = err instanceof TransactionCanceledException &&
+                    ((_a = err.CancellationReasons) === null || _a === void 0 ? void 0 : _a.some((reason) => reason.Code === BatchStatementErrorCodeEnum.ConditionalCheckFailed));
+                const isMutualIsUndefined = err instanceof StandardError &&
+                    err.code === StandardErrorCode.MUTUAL_IS_UNDEFINED;
+                if (isConditionalCheckFailed || isMutualIsUndefined) {
+                    throw new StandardError(StandardErrorCode.MUTUAL_NOT_FOUND, 'Mutual not found', err, {
+                        errorContext,
+                    });
+                }
+                throw err;
+            }
+        });
+    }
+    createMutualLock(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ byEntityType, byEntityId, entityType, version, }) {
+            var _b, _c, _d;
+            let retryCount = 2;
+            const itemKey = {
+                PK: {
+                    S: `MUTUAL#${byEntityType}#${byEntityId}#${entityType}`,
                 },
-                {
-                    Update: {
+                SK: { S: '#LOCK#' },
+            };
+            do {
+                try {
+                    const fiveMinsLater = Math.floor(new Date().getTime() / 1000 + 5 * 60);
+                    yield this.dynamodbClient.putItem({
                         TableName: this.TABLE_NAME,
-                        Key: {
-                            PK: { S: mutual.fullEntityId },
-                            SK: { S: mutual.byFullEntityId },
+                        Item: Object.assign(Object.assign({}, itemKey), { version: { S: version }, status: { S: 'LOCK' }, expiresAt: {
+                                // auto release lock in case the mutual logic gone wrong to prevent dead lock
+                                N: `${fiveMinsLater}`,
+                            } }),
+                        ConditionExpression: 'attribute_not_exists(PK) OR version < :version AND #status <> :status',
+                        ExpressionAttributeNames: { '#status': 'status' },
+                        ExpressionAttributeValues: {
+                            ':version': { S: version },
+                            ':status': { S: 'LOCK' },
                         },
-                        ...expressions,
-                    },
-                },
-            ];
-            errorContext.TransactItems = TransactItems;
-            await this.dynamodbClient.transactWriteItems({ TransactItems });
-            return mutual;
-        }
-        catch (err) {
-            const isConditionalCheckFailed = err instanceof TransactionCanceledException &&
-                err.CancellationReasons?.some((reason) => reason.Code === BatchStatementErrorCodeEnum.ConditionalCheckFailed);
-            const isMutualIsUndefined = err instanceof StandardError && err.code === 'MUTUAL_IS_UNDEFINED';
-            if (isConditionalCheckFailed || isMutualIsUndefined) {
-                throw new StandardError('MUTUAL_NOT_FOUND', 'Mutual not found', err, {
-                    errorContext,
-                });
-            }
-            throw err;
-        }
+                    });
+                    return;
+                }
+                catch (err) {
+                    console.log('=====CATCHED_MUTUAL_LOCK_CONFLICT=====');
+                    const lock = yield this.dynamodbClient.getItem({
+                        TableName: this.TABLE_NAME,
+                        Key: itemKey,
+                    });
+                    // if version is lower, throw not retryable error to skip
+                    const existingVersion = (_d = (_c = (_b = lock.Item) === null || _b === void 0 ? void 0 : _b.version) === null || _c === void 0 ? void 0 : _c.S) !== null && _d !== void 0 ? _d : '';
+                    const isExistingVersionGreaterThanNewVersion = existingVersion >= version;
+                    if (isExistingVersionGreaterThanNewVersion) {
+                        throw new StandardError(StandardErrorCode.MUTUAL_LOCK_CONFLICT, 'Lock conflict', err, { lock: lock.Item });
+                    }
+                    // default behaviour
+                    // if version is higher, retry
+                    // if lock not found, retry
+                    yield sleep(2000);
+                    console.log('=====RETRY_MUTUAL_LOCK=====');
+                }
+            } while (retryCount-- > 0);
+            // catch real unhandled error, so it can reach DLQ for inspection
+            throw new StandardError(StandardErrorCode.RETRYABLE_MUTUAL_LOCK_CONFLICT, 'Retryable lock conflict');
+        });
     }
-    async createMutualLock({ byEntityType, byEntityId, entityType, version, }) {
-        let retryCount = 2;
-        const itemKey = {
-            PK: {
-                S: `MUTUAL#${byEntityType}#${byEntityId}#${entityType}`,
-            },
-            SK: { S: '#LOCK#' },
-        };
-        do {
+    deleteMutualLock(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ byEntityType, byEntityId, entityType, }) {
             try {
-                const fiveMinsLater = Math.floor(new Date().getTime() / 1000 + 5 * 60);
-                await this.dynamodbClient.putItem({
+                yield this.dynamodbClient.updateItem({
                     TableName: this.TABLE_NAME,
-                    Item: {
-                        ...itemKey,
-                        version: { S: version },
-                        status: { S: 'LOCK' },
-                        expiresAt: {
-                            // auto release lock in case the mutual logic gone wrong to prevent dead lock
-                            N: `${fiveMinsLater}`,
+                    Key: {
+                        PK: {
+                            S: `MUTUAL#${byEntityType}#${byEntityId}#${entityType}`,
                         },
+                        SK: { S: '#LOCK#' },
                     },
-                    ConditionExpression: 'attribute_not_exists(PK) OR version < :version AND #status <> :status',
+                    UpdateExpression: 'REMOVE #status',
                     ExpressionAttributeNames: { '#status': 'status' },
-                    ExpressionAttributeValues: {
-                        ':version': { S: version },
-                        ':status': { S: 'LOCK' },
-                    },
                 });
                 return;
             }
-            catch (err) {
-                console.log('=====CATCHED_MUTUAL_LOCK_CONFLICT=====');
-                const lock = await this.dynamodbClient.getItem({
-                    TableName: this.TABLE_NAME,
-                    Key: itemKey,
-                });
-                // if version is lower, throw not retryable error to skip
-                const existingVersion = lock.Item?.version?.S ?? '';
-                const isExistingVersionGreaterThanNewVersion = existingVersion >= version;
-                if (isExistingVersionGreaterThanNewVersion) {
-                    throw new StandardError('MUTUAL_LOCK_CONFLICT', 'Lock conflict', err, { lock: lock.Item });
-                }
-                // default behaviour
-                // if version is higher, retry
-                // if lock not found, retry
-                await sleep(2000);
-                console.log('=====RETRY_MUTUAL_LOCK=====');
+            catch (error) {
+                // if lock is not found, it's okay
             }
-        } while (retryCount-- > 0);
-        // catch real unhandled error, so it can reach DLQ for inspection
-        throw new StandardError('RETRYABLE_MUTUAL_LOCK_CONFLICT', 'Retryable lock conflict');
-    }
-    async deleteMutualLock({ byEntityType, byEntityId, entityType, }) {
-        try {
-            await this.dynamodbClient.updateItem({
-                TableName: this.TABLE_NAME,
-                Key: {
-                    PK: {
-                        S: `MUTUAL#${byEntityType}#${byEntityId}#${entityType}`,
-                    },
-                    SK: { S: '#LOCK#' },
-                },
-                UpdateExpression: 'REMOVE #status',
-                ExpressionAttributeNames: { '#status': 'status' },
-            });
-            return;
-        }
-        catch (error) {
-            // if lock is not found, it's okay
-        }
+        });
     }
 }
 //# sourceMappingURL=Mutual.js.map