dyna-record 0.1.5 → 0.2.1

package/dist/src/operations/Update/Update.js

@@ -8,41 +8,201 @@ const utils_1 = require("../../utils");
 const utils_2 = require("../utils");
 const OperationBase_1 = __importDefault(require("../OperationBase"));
 const metadata_1 = __importDefault(require("../../metadata"));
+const errors_1 = require("../../errors");
+const utils_3 = require("../../metadata/utils");
 /**
- * Facilitates the operation of updating an existing entity in the database, including handling updates to its attributes and managing changes to its relationships. It will de-normalize data to support relationship links
+ * Represents an update operation for a DynaRecord-backed entity, handling both attribute updates and relationship consistency via denormalization.
  *
- * The `Update` operation supports updating entity attributes and ensures consistency in relationships, especially for "BelongsTo" relationships. It handles the complexity of managing foreign keys and associated "BelongsToLink" records, including creating new links for updated relationships and removing outdated links when necessary.
+ * This class supports updating an existing entity and managing its relational links, specifically:
+ * - Updating entity attributes while preserving schema constraints.
+ * - Managing "BelongsTo" relationship links by creating or removing associated denormalized records.
+ * - Ensuring that if a foreign key changes, the old link record is removed, preventing stale references.
  *
- * Only attributes defined on the model can be configured, and will be enforced via types and runtime schema validation.
+ * Only attributes defined on the model can be updated. Both compile-time and runtime checks help ensure that updated values are valid.
+ *
+ * **Example**
+ * ```typescript
+ * const updateOp = new Update(MyEntityClass);
+ * await updateOp.run("entityId", { name: "NewName", status: "active" });
+ * ```
  *
  * @template T - The type of the entity being updated, extending `DynaRecord`.
  */
 class Update extends OperationBase_1.default {
-    #transactionBuilder;
-    #entity;
-    constructor(Entity) {
+    transactionBuilder;
+    constructor(Entity, transactionBuilder) {
         super(Entity);
-        this.#transactionBuilder = new dynamo_utils_1.TransactWriteBuilder();
+        // Use the transaction builder passed to the class, or instantiate a new one
+        this.transactionBuilder = transactionBuilder ?? new dynamo_utils_1.TransactWriteBuilder();
     }
     /**
-     * Update entity transactions, including transactions to create/update BelongsToLinks
-     * @param id The id of the entity being updated
-     * @param attributes Attributes on the model to update.
+     * Executes the update operation against DynamoDB.
+     *
+     * **What it does:**
+     * - Fetches the current state of the entity and any related "Has" relationship entities.
+     * - Constructs an update expression for the main entity's attributes.
+     * - Applies the same update expression to related entities and "BelongsTo" link records to maintain denormalized consistency.
+     * - Manages foreign key changes by creating new link items and removing old link items.
+     *
+     * @param id - The unique identifier of the entity being updated.
+     * @param attributes - Partial set of entity attributes to update. Must be defined on the entity's model.
+     * @returns A promise that resolves to the set of updated attributes as applied to the entity.
+     * @throws If the entity does not exist, an error is thrown.
      */
     async run(id, attributes) {
         const entityMeta = metadata_1.default.getEntity(this.EntityClass.name);
         const entityAttrs = entityMeta.parseRawEntityDefinedAttributesPartial(attributes);
-        const updatedAttrs = this.buildUpdateItemTransaction(id, entityAttrs);
-        await this.buildRelationshipTransactions(id, entityAttrs);
-        await this.#transactionBuilder.executeTransaction();
+        const { updatedAttrs, expression } = this.buildUpdateMetadata(entityAttrs);
+        this.buildUpdateItemTransaction(id, expression);
+        // Only need to prefetch if the entity has relationships
+        if (entityMeta.allRelationships.length > 0) {
+            const belongsToRelMetaBeingUpdated = this.getBelongsToRelMetaAndKeyForUpdatedKeys(entityAttrs);
+            const entities = await this.preFetch(id, belongsToRelMetaBeingUpdated);
+            const preFetch = this.preProcessFetchedData(id, entities, belongsToRelMetaBeingUpdated);
+            const updatedEntity = {
+                ...preFetch.entityPreUpdate,
+                ...updatedAttrs,
+                id
+            };
+            this.buildUpdateRelatedEntityLinks(id, preFetch.relatedEntities, expression);
+            this.buildBelongsToTransactions(preFetch.entityPreUpdate, updatedEntity, expression, preFetch.newBelongsToEntityLookup);
+        }
+        await this.commitTransaction();
         return updatedAttrs;
     }
+    async commitTransaction() {
+        await this.transactionBuilder.executeTransaction();
+    }
     /**
-     * Build the transaction to update the entity
-     * @param id The id of the entity being updated
-     * @param attributes Attributes on the model to update.
+     * BelongsToRelationship meta data and foreign key value pair for foreign keys being updated
+     * @param attributes
+     * @returns
      */
-    buildUpdateItemTransaction(id, attributes) {
+    getBelongsToRelMetaAndKeyForUpdatedKeys(attributes) {
+        return this.entityMetadata.belongsToRelationships.reduce((acc, meta) => {
+            const foreignKeyVal = (0, utils_2.extractForeignKeyFromEntity)(meta, attributes);
+            if (foreignKeyVal !== undefined)
+                acc.push({ meta, foreignKeyVal });
+            return acc;
+        }, []);
+    }
+    /**
+     * Pre-fetches the target entity and any related entities from the database. This is done using a strong read operation to ensure consistency.
+     *
+     * **What it does:**
+     * - Retrieves the main entity and all linked entities in the entity's partition.
+     * - Performs a TransactGetItem operation on entities linked bai foreign keys (BelongsTo) to support denormalizing copies to associated partitions
+     * - Filters these entities to separate the main entity and its related link records.
+     *
+     * @param id - The unique identifier of the entity being fetched.
+     * @param belongsToRelFkAndMetas - BelongsTo relationship meta objects with foreign keys used for fetching associated records
+     * @returns A promise that resolves to an object containing:
+     *   - `entityPreUpdate`: The current state of the entity before updates.
+     *   - `relatedEntities`: An array of related link entities.
+     * @throws If the entity does not exist, it throws a NotFoundError.
+     * @private
+     */
+    async preFetch(id, belongsToRelFkAndMetas) {
+        const hasRelMetas = this.entityMetadata.hasRelationships.filter(rel => !(0, utils_3.isHasManyRelationship)(rel) || rel.uniDirectional !== true);
+        const { name: tableName } = this.tableMetadata;
+        const transactionBuilder = new dynamo_utils_1.TransactGetBuilder();
+        // Get the new BelongsTo relationship entities that are being updated
+        belongsToRelFkAndMetas.forEach(({ meta, foreignKeyVal }) => {
+            if (foreignKeyVal !== null) {
+                transactionBuilder.addGet({
+                    TableName: tableName,
+                    Key: {
+                        [this.partitionKeyAlias]: meta.target.partitionKeyValue(foreignKeyVal),
+                        [this.sortKeyAlias]: meta.target.name
+                    }
+                });
+            }
+        });
+        const typeAlias = this.tableMetadata.defaultAttributes.type.alias;
+        // Get linked items from entity being updates partition as well as new foreign entities if adding or updating an FK
+        const [transactionResults, selfAndLinkedEntities] = await Promise.all([
+            transactionBuilder.executeTransaction(),
+            this.EntityClass.query(id, {
+                filter: {
+                    type: [
+                        this.EntityClass.name,
+                        ...hasRelMetas.map(meta => meta.target.name)
+                    ]
+                }
+            })
+        ]);
+        // Serialize table items to entities
+        const foreignEntities = transactionResults.reduce((acc, res) => {
+            if (res.Item !== undefined && (0, utils_1.isString)(res.Item[typeAlias])) {
+                const entityMeta = metadata_1.default.getEntity(res.Item[typeAlias]);
+                const entity = (0, utils_1.tableItemToEntity)(entityMeta.EntityClass, res.Item);
+                acc.push(entity);
+            }
+            return acc;
+        }, []);
+        return [...selfAndLinkedEntities, ...foreignEntities];
+    }
+    /**
+     * {reprocess pre-fetch data for processing
+     * @param id
+     * @param entities
+     * @param belongsToRelFkAndMetas
+     * @returns
+     */
+    preProcessFetchedData(id, entities, belongsToRelFkAndMetas) {
+        let entityPreUpdate;
+        const relatedEntities = [];
+        const newBelongsToEntityLookup = {};
+        entities.forEach(entity => {
+            if (id === entity.id) {
+                entityPreUpdate = entity;
+            }
+            else if (belongsToRelFkAndMetas.some(obj => obj.foreignKeyVal === entity.id)) {
+                newBelongsToEntityLookup[entity.id] = entity;
+            }
+            else {
+                relatedEntities.push(entity);
+            }
+        });
+        if (entityPreUpdate === undefined) {
+            throw new errors_1.NotFoundError(`${this.EntityClass.name} does not exist: ${id}`);
+        }
+        return { entityPreUpdate, relatedEntities, newBelongsToEntityLookup };
+    }
+    /**
+     * Constructs updated attributes and the corresponding DynamoDB update expression.
+     *
+     * **What it does:**
+     * - Merges the provided attributes with `updatedAt` (automatically set to the current time).
+     * - Converts the updated attributes into a DynamoDB update expression.
+     *
+     * @param attributes - The partial attributes to be updated on the entity.
+     * @returns An object containing:
+     *   - `updatedAttrs`: The final updated attribute set.
+     *   - `expression`: A DynamoDB update expression to apply these changes.
+     * @private
+     */
+    buildUpdateMetadata(attributes) {
+        const updatedAttrs = {
+            ...attributes,
+            updatedAt: new Date()
+        };
+        const tableAttrs = (0, utils_1.entityToTableItem)(this.EntityClass, updatedAttrs);
+        const expression = (0, utils_2.expressionBuilder)(tableAttrs);
+        return { updatedAttrs, expression };
+    }
+    /**
+     * Adds a transaction operation to update the main entity's record.
+     *
+     * **What it does:**
+     * - Builds a DynamoDB Update transaction using the provided update expression.
+     * - Adds a condition to ensure the entity exists before updating.
+     *
+     * @param id - The unique identifier of the entity being updated.
+     * @param updateExpression - The DynamoDB update expression describing the changes.
+     * @private
+     */
+    buildUpdateItemTransaction(id, updateExpression) {
         const { name: tableName } = this.tableMetadata;
         const pk = this.tableMetadata.partitionKeyAttribute.name;
         const sk = this.tableMetadata.sortKeyAttribute.name;
@@ -50,76 +210,253 @@ class Update extends OperationBase_1.default {
             [pk]: this.EntityClass.partitionKeyValue(id),
             [sk]: this.EntityClass.name
         };
-        const updatedAttrs = {
-            ...attributes,
-            updatedAt: new Date()
-        };
         const tableKeys = (0, utils_1.entityToTableItem)(this.EntityClass, keys);
-        const tableAttrs = (0, utils_1.entityToTableItem)(this.EntityClass, updatedAttrs);
-        const expression = (0, utils_2.expressionBuilder)(tableAttrs);
-        this.#transactionBuilder.addUpdate({
+        this.transactionBuilder.addUpdate({
             TableName: tableName,
             Key: tableKeys,
-            ConditionExpression: `attribute_exists(${this.partitionKeyAlias})`, // Only update the item if it exists
-            ...expression
+            ConditionExpression: `attribute_exists(${this.partitionKeyAlias})`,
+            ...updateExpression
         }, `${this.EntityClass.name} with ID '${id}' does not exist`);
-        return updatedAttrs;
     }
     /**
-     * Builds the transactions to persist relationships
-     *   - Creates BelongsToLinks when a foreign key changes
-     *   - Removes outdated BelongsToLinks if the entity previously was associated with a different entity
-     * @param id The id of the entity being updated
-     * @param attributes Attributes on the model to update.
-     */
-    async buildRelationshipTransactions(id, attributes) {
-        const entityData = { id, ...attributes };
-        const relationshipTransactions = new utils_2.RelationshipTransactions({
-            Entity: this.EntityClass,
-            transactionBuilder: this.#transactionBuilder,
-            belongsToHasManyCb: async (rel, entityId) => {
-                const entity = await this.getEntity(entityId);
-                this.buildDeleteOldBelongsToLinkTransaction(rel, "HasMany", entity);
-            },
-            belongsToHasOneCb: async (rel, entityId) => {
-                const entity = await this.getEntity(entityId);
-                this.buildDeleteOldBelongsToLinkTransaction(rel, "HasOne", entity);
+     * Builds all necessary transactions to handle "BelongsTo" or uni-directional "OwnedBy" relationships when updating the entity.
+     *
+     * **What it does:**
+     * - Checks if any foreign keys for "BelongsTo" or uni-directional "OwnedBy" relationships have changed.
+     * - If so, updates or creates new denormalized link records in the related partitions.
+     * - Removes old link records that are no longer valid due to foreign key changes.
+     *
+     * @param entityPreUpdate - The state of the entity before the update.
+     * @param updatedEntity - The entity state after proposed updates (partial attributes).
+     * @param updateExpression - The DynamoDB update expression representing the attribute updates.
+     * @private
+     */
+    buildBelongsToTransactions(entityPreUpdate, updatedEntity, updateExpression, newBelongsToEntityLookup) {
+        const entityId = entityPreUpdate.id;
+        const relMetas = this.entityMetadata.belongsToOrOwnedByRelationships;
+        for (const relMeta of relMetas) {
+            const foreignKey = (0, utils_2.extractForeignKeyFromEntity)(relMeta, updatedEntity);
+            const isUpdatingRelationshipId = foreignKey !== undefined;
+            if (isUpdatingRelationshipId && (0, utils_1.isNullableString)(foreignKey)) {
+                // Handle removal of old link if the foreign key changed.
+                const oldFk = (0, utils_2.extractForeignKeyFromEntity)(relMeta, entityPreUpdate);
+                const isAddingForeignKey = oldFk === undefined && foreignKey !== null;
+                const isUpdatingForeignKey = oldFk !== undefined && oldFk !== foreignKey;
+                const isRemovingForeignKey = isUpdatingForeignKey && foreignKey === null;
+                if (isAddingForeignKey) {
+                    this.buildPutBelongsToLinkedRecords(updatedEntity, relMeta, foreignKey, newBelongsToEntityLookup, "attribute_not_exists", `${this.EntityClass.name} already has an associated ${relMeta.target.name}`);
+                }
+                else if (isRemovingForeignKey) {
+                    this.removeForeignKeysTransactions(entityId, relMeta, oldFk);
+                }
+                else if (isUpdatingForeignKey) {
+                    this.updateForeignKeyTransactions(updatedEntity, relMeta, foreignKey, oldFk, newBelongsToEntityLookup);
+                }
+                else if (foreignKey !== null) {
+                    this.buildUpdateBelongsToLinkedRecords(entityId, relMeta, foreignKey, updateExpression);
+                }
             }
-        });
-        await relationshipTransactions.build(entityData);
+        }
     }
     /**
-     * When updating the foreign key of an entity, delete the BelongsToLink in the previous relationships partition
-     * @param rel
-     * @param relType
-     * @param entity
+     * Creates or updates the denormalized link record for a "BelongsTo" relationship to the related entity's partition.
+     *
+     * **What it does:**
+     * - Builds a DynamoDB Update transaction for the linked record identified by the relationship and foreign key.
+     * - Ensures the linked record exists before updating (if not, it will fail).
+     *
+     * @param entityId - The identifier of the main entity being updated.
+     * @param relMeta - Metadata describing the "BelongsTo" relationship.
+     * @param foreignKey - The new foreign key value after updates.
+     * @param updateExpression - The DynamoDB update expression for the attribute changes.
+     * @private
      */
-    buildDeleteOldBelongsToLinkTransaction(rel, relType, entity) {
+    buildUpdateBelongsToLinkedRecords(entityId, relMeta, foreignKey, updateExpression) {
         const { name: tableName } = this.tableMetadata;
-        const currentId = (0, utils_2.extractForeignKeyFromEntity)(rel, entity);
-        if (entity !== undefined && currentId !== undefined) {
-            const oldLinkKeys = {
-                [this.partitionKeyAlias]: rel.target.partitionKeyValue(currentId),
-                [this.sortKeyAlias]: relType === "HasMany"
-                    ? this.EntityClass.partitionKeyValue(entity.id)
-                    : this.EntityClass.name
-            };
-            this.#transactionBuilder.addDelete({
-                TableName: tableName,
-                Key: oldLinkKeys
-            });
+        const newKey = (0, utils_2.buildBelongsToLinkKey)(this.EntityClass, entityId, relMeta, foreignKey);
+        this.transactionBuilder.addUpdate({
+            TableName: tableName,
+            Key: newKey,
+            ConditionExpression: `attribute_exists(${this.partitionKeyAlias})`,
+            ...updateExpression
+        });
+    }
+    /**
+     * Builds transactions to persist an updated/new belongs to record
+     * Denormalizes data to the entity being updates's partition and a link to the foreign entities partition
+     * Ensures that the new entity foreign key exists
+     * @param updatedEntity
+     * @param relMeta
+     * @param foreignKey
+     * @param newBelongsToEntityLookup
+     * @param persistToSelfCondition
+     * @param persistToSelfConditionErrMessage
+     */
+    buildPutBelongsToLinkedRecords(updatedEntity, relMeta, foreignKey, newBelongsToEntityLookup, persistToSelfCondition, persistToSelfConditionErrMessage) {
+        // Ensure that the new foreign key is valid and exists
+        this.buildEntityExistsCondition(relMeta, foreignKey);
+        // Denormalize entity being updated to foreign partition
+        this.buildLinkToForeignEntityTransaction(updatedEntity, relMeta, foreignKey);
+        if ((0, utils_3.isBelongsToRelationship)(relMeta)) {
+            // Add denormalized record for new entity to self
+            this.buildAddForeignEntityToSelfTransaction(updatedEntity, relMeta, foreignKey, newBelongsToEntityLookup, persistToSelfCondition, persistToSelfConditionErrMessage);
+        }
+    }
+    /**
+     * Builds a condition expression that an entity exists
+     * @param relMeta
+     * @param foreignKey
+     */
+    buildEntityExistsCondition(relMeta, foreignKey) {
+        const errMsg = `${relMeta.target.name} with ID '${foreignKey}' does not exist`;
+        const conditionCheck = {
+            TableName: this.tableMetadata.name,
+            Key: {
+                [this.partitionKeyAlias]: relMeta.target.partitionKeyValue(foreignKey),
+                [this.sortKeyAlias]: relMeta.target.name
+            },
+            ConditionExpression: `attribute_exists(${this.partitionKeyAlias})`
+        };
+        this.transactionBuilder.addConditionCheck(conditionCheck, errMsg);
+    }
+    /**
+     * Denormalizes a link for the entity being updated to the new entities partition
+     * @param updatedEntity
+     * @param relMeta
+     * @param foreignKey
+     */
+    buildLinkToForeignEntityTransaction(updatedEntity, relMeta, foreignKey) {
+        const key = (0, utils_2.buildBelongsToLinkKey)(this.EntityClass, updatedEntity.id, relMeta, foreignKey);
+        const tableItem = (0, utils_1.entityToTableItem)(this.EntityClass, updatedEntity);
+        this.transactionBuilder.addPut({
+            TableName: this.tableMetadata.name,
+            Item: { ...tableItem, ...key },
+            ConditionExpression: `attribute_not_exists(${this.partitionKeyAlias})`
+        }, `${relMeta.target.name} with id: ${foreignKey} already has an associated ${this.EntityClass.name}`);
+    }
+    /**
+     * Builds the transaction to add or replace the linked record for the foreign entity in the entity being updates partition
+     * @param updatedEntity
+     * @param relMeta
+     * @param foreignKey
+     * @param newBelongsToEntityLookup
+     * @param persistToSelfCondition
+     * @param persistToSelfConditionErrMessage
+     */
+    buildAddForeignEntityToSelfTransaction(updatedEntity, relMeta, foreignKey, newBelongsToEntityLookup, persistToSelfCondition, persistToSelfConditionErrMessage) {
+        const linkedEntity = newBelongsToEntityLookup[foreignKey];
+        if (linkedEntity === undefined) {
+            throw new errors_1.NotFoundError(`${relMeta.target.name} does not exist: ${foreignKey}`);
         }
+        const key = {
+            [this.partitionKeyAlias]: this.EntityClass.partitionKeyValue(updatedEntity.id),
+            [this.sortKeyAlias]: relMeta.target.name
+        };
+        const linkedRecordTableItem = (0, utils_1.entityToTableItem)(relMeta.target, linkedEntity);
+        this.transactionBuilder.addPut({
+            TableName: this.tableMetadata.name,
+            Item: { ...linkedRecordTableItem, ...key },
+            ConditionExpression: `${persistToSelfCondition}(${this.partitionKeyAlias})`
+        }, persistToSelfConditionErrMessage);
+    }
+    /**
+     * Removes the old link record associated with a previous "BelongsTo" foreign key when the foreign key changes.
+     *
+     * **What it does:**
+     * - Builds a DynamoDB Delete transaction to remove the stale link record from the old relationship partition.
+     *
+     * @param entityId - The identifier of the entity whose foreign key was changed.
+     * @param relMeta - Metadata describing the "BelongsTo" relationship.
+     * @param oldForeignKey - The old foreign key value that should no longer link to the entity.
+     * @private
+     */
+    removeForeignKeysTransactions(entityId, relMeta, oldForeignKey) {
+        // Keys to delete the denormalized record from entities own partition
+        const oldKeysToSelf = {
+            [this.partitionKeyAlias]: this.EntityClass.partitionKeyValue(entityId),
+            [this.sortKeyAlias]: relMeta.target.name
+        };
+        // Keys to delete the linked record from the foreign entities partition
+        const oldKeysToForeignEntity = (0, utils_2.buildBelongsToLinkKey)(this.EntityClass, entityId, relMeta, oldForeignKey);
+        // OwnedByRelationships do not have a record to delete from  their own partition because its unidirectional
+        if ((0, utils_3.isBelongsToRelationship)(relMeta)) {
+            this.transactionBuilder.addDelete({
+                TableName: this.tableMetadata.name,
+                Key: oldKeysToSelf
+            }, `Failed to delete denormalized record with keys: ${JSON.stringify(oldKeysToSelf)}`);
+        }
+        this.transactionBuilder.addDelete({
+            TableName: this.tableMetadata.name,
+            Key: oldKeysToForeignEntity
+        }, `Failed to delete denormalized record with keys: ${JSON.stringify(oldKeysToForeignEntity)}`);
+    }
+    /**
+     * Builds the transactions for updating the foreign key of an entity from one key to another
+     * @param updatedEntity
+     * @param relMeta
+     * @param newForeignKey
+     * @param oldForeignKey
+     * @param newBelongsToEntityLookup
+     */
+    updateForeignKeyTransactions(updatedEntity, relMeta, newForeignKey, oldForeignKey, newBelongsToEntityLookup) {
+        // Keys to delete the linked record from the foreign entities partition
+        const oldKeysToForeignEntity = (0, utils_2.buildBelongsToLinkKey)(this.EntityClass, updatedEntity.id, relMeta, oldForeignKey);
+        this.transactionBuilder.addDelete({
+            TableName: this.tableMetadata.name,
+            Key: oldKeysToForeignEntity
+        });
+        this.buildPutBelongsToLinkedRecords(updatedEntity, relMeta, newForeignKey, newBelongsToEntityLookup, "attribute_exists");
     }
     /**
-     * If updating a ForeignKey, look up the current state of the item to build transactions
+     * Builds transactions to update all related entities that exist in the main entity's partition, applying the same attribute updates.
+     *
+     * **What it does:**
+     * - For each linked entity found in `preFetch`, attempts to apply the same update expression.
+     * - Ensures each related entity exists before attempting to update.
+     *
+     * @param relatedEntities - An array of entities that are related to the primary entity and need synchronized attribute updates.
+     * @param expression - The DynamoDB update expression to apply to related entities.
+     * @private
      */
-    async getEntity(id) {
-        // Only get the item once per transaction
-        if (this.#entity !== undefined)
-            return this.#entity;
-        const res = (await this.EntityClass.findById(id));
-        this.#entity = res ?? undefined;
-        return this.#entity;
+    buildUpdateRelatedEntityLinks(entityId, relatedEntities, expression) {
+        const hasAndBelongsToManyLookup = this.buildHasAndBelongsToManyRelLookup();
+        relatedEntities.forEach(entity => {
+            this.transactionBuilder.addUpdate({
+                TableName: this.tableMetadata.name,
+                Key: this.buildUpdatedRelatedEntityLinkKey(entityId, entity, hasAndBelongsToManyLookup),
+                ConditionExpression: `attribute_exists(${this.partitionKeyAlias})`,
+                ...expression
+            }, `${entity.constructor.name} (${entity.id}) is not associated with ${this.EntityClass.name} (${entityId})`);
+        });
+    }
+    /**
+     * Builds the table key for a related entity that needs to be updated
+     * @param id - The id of the entity being updated
+     * @param entity
+     * @param relLookup
+     * @returns
+     */
+    buildUpdatedRelatedEntityLinkKey(id, entity, relLookup) {
+        const isHasAndBelongsToManyRel = relLookup[entity.type] !== undefined;
+        const sortKey = isHasAndBelongsToManyRel
+            ? this.EntityClass.partitionKeyValue(id)
+            : this.EntityClass.name;
+        return {
+            [this.partitionKeyAlias]: entity.partitionKeyValue(),
+            [this.sortKeyAlias]: sortKey
+        };
+    }
+    /**
+     * Build a lookup object to lookup a HasAndBelongsToMany relationship for an entity. Used for processing to avoid excessive looping
+     * @returns
+     */
+    buildHasAndBelongsToManyRelLookup() {
+        return Object.values(this.entityMetadata.relationships).reduce((acc, rel) => {
+            if (rel.type === "HasAndBelongsToMany") {
+                acc[rel.target.name] = rel;
+            }
+            return acc;
+        }, {});
     }
 }
 exports.default = Update;

package/dist/src/operations/Update/UpdateDryRun.d.ts

@@ -0,0 +1,10 @@
+import type DynaRecord from "../../DynaRecord";
+import Update from "./Update";
+/**
+ * Runs Update operation with out committing the transaction
+ */
+declare class UpdateDryRun<T extends DynaRecord> extends Update<T> {
+    protected commitTransaction(): Promise<void>;
+}
+export default UpdateDryRun;
+//# sourceMappingURL=UpdateDryRun.d.ts.map

package/dist/src/operations/Update/UpdateDryRun.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UpdateDryRun.d.ts","sourceRoot":"","sources":["../../../../src/operations/Update/UpdateDryRun.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,MAAM,MAAM,UAAU,CAAC;AAE9B;;GAEG;AACH,cAAM,YAAY,CAAC,CAAC,SAAS,UAAU,CAAE,SAAQ,MAAM,CAAC,CAAC,CAAC;cAC/B,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5D;AAED,eAAe,YAAY,CAAC"}

package/dist/src/operations/Update/UpdateDryRun.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Update_1 = __importDefault(require("./Update"));
+/**
+ * Runs Update operation with out committing the transaction
+ */
+class UpdateDryRun extends Update_1.default {
+    async commitTransaction() {
+        // No-op
+    }
+}
+exports.default = UpdateDryRun;

package/dist/src/operations/Update/index.d.ts

@@ -1,3 +1,4 @@
 export { default as Update } from "./Update";
 export * from "./types";
+export { default as UpdateDryRun } from "./UpdateDryRun";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/operations/Update/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/operations/Update/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,UAAU,CAAC;AAC7C,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/operations/Update/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,UAAU,CAAC;AAC7C,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/src/operations/Update/index.js

@@ -17,7 +17,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Update = void 0;
+exports.UpdateDryRun = exports.Update = void 0;
 var Update_1 = require("./Update");
 Object.defineProperty(exports, "Update", { enumerable: true, get: function () { return __importDefault(Update_1).default; } });
 __exportStar(require("./types"), exports);
+var UpdateDryRun_1 = require("./UpdateDryRun");
+Object.defineProperty(exports, "UpdateDryRun", { enumerable: true, get: function () { return __importDefault(UpdateDryRun_1).default; } });

package/dist/src/operations/types.d.ts

@@ -44,10 +44,15 @@ export type ForeignKeyToValue<T> = {
 export type RelationshipAttributeNames<T> = {
     [K in keyof T]: Exclude<T[K], undefined> extends DynaRecord | DynaRecord[] ? K : never;
 }[keyof T];
+/**
+ * Entity class instance with attributes excluding relationship attributes
+ */
+export type EntityAttributesInstance<T extends DynaRecord> = Omit<T, RelationshipAttributeNames<T>>;
 /**
  * Entity attributes excluding relationship attributes
+ * Represents the raw attributes of a class (no functions)
  */
-export type EntityAttributes<T extends DynaRecord> = Omit<T, RelationshipAttributeNames<T> | FunctionFields<T>>;
+export type EntityAttributesOnly<T extends DynaRecord> = Omit<T, RelationshipAttributeNames<T> | FunctionFields<T>>;
 /**
  * Entity attributes for default fields
  */

package/dist/src/operations/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/operations/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EACV,UAAU,EACV,kBAAkB,EAClB,QAAQ,EACR,YAAY,EACZ,OAAO,EACR,MAAM,UAAU,CAAC;AAElB;;;;;GAKG;AACH,MAAM,MAAM,qBAAqB,CAAC,CAAC,IAAI;KACpC,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,YAAY,GAAG,CAAC,GAAG,KAAK;CACtD,CAAC,MAAM,CAAC,CAAC,CAAC;AAEX;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI;KAC/B,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,OAAO,GAAG,CAAC,GAAG,KAAK;CACjD,CAAC,MAAM,CAAC,CAAC,CAAC;AAEX;;;;;GAKG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI;KAC7B,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GAAG,CAAC,GAAG,KAAK;CACjE,CAAC,MAAM,CAAC,CAAC,CAAC;AAEX;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI;KAChC,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,kBAAkB,GAC3C,QAAQ,CAAC,MAAM,CAAC,GAChB,CAAC,CAAC,CAAC,CAAC,SAAS,UAAU,GACrB,MAAM,GACN,CAAC,CAAC,CAAC,CAAC;CACX,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,0BAA0B,CAAC,CAAC,IAAI;KACzC,CAAC,IAAI,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,UAAU,GAAG,UAAU,EAAE,GACtE,CAAC,GACD,KAAK;CACV,CAAC,MAAM,CAAC,CAAC,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,UAAU,IAAI,IAAI,CACvD,CAAC,EACD,0BAA0B,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAClD,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,4BAA4B,GAAG,IAAI,CAC7C,UAAU,EACV,OAAO,CAAC,MAAM,UAAU,EAAE,aAAa,CAAC,CACzC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,UAAU,IAAI,IAAI,CAC9D,iBAAiB,CAAC,CAAC,CAAC,EAClB,MAAM,UAAU,GAChB,0BAA0B,CAAC,CAAC,CAAC,GAC7B,cAAc,CAAC,CAAC,CAAC,GACjB,qBAAqB,CAAC,CAAC,CAAC,GACxB,gBAAgB,CAAC,CAAC,CAAC,CACtB,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/operations/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EACV,UAAU,EACV,kBAAkB,EAClB,QAAQ,EACR,YAAY,EACZ,OAAO,EACR,MAAM,UAAU,CAAC;AAElB;;;;;GAKG;AACH,MAAM,MAAM,qBAAqB,CAAC,CAAC,IAAI;KACpC,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,YAAY,GAAG,CAAC,GAAG,KAAK;CACtD,CAAC,MAAM,CAAC,CAAC,CAAC;AAEX;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI;KAC/B,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,OAAO,GAAG,CAAC,GAAG,KAAK;CACjD,CAAC,MAAM,CAAC,CAAC,CAAC;AAEX;;;;;GAKG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI;KAC7B,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GAAG,CAAC,GAAG,KAAK;CACjE,CAAC,MAAM,CAAC,CAAC,CAAC;AAEX;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI;KAChC,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,kBAAkB,GAC3C,QAAQ,CAAC,MAAM,CAAC,GAChB,CAAC,CAAC,CAAC,CAAC,SAAS,UAAU,GACrB,MAAM,GACN,CAAC,CAAC,CAAC,CAAC;CACX,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,0BAA0B,CAAC,CAAC,IAAI;KACzC,CAAC,IAAI,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,UAAU,GAAG,UAAU,EAAE,GACtE,CAAC,GACD,KAAK;CACV,CAAC,MAAM,CAAC,CAAC,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,wBAAwB,CAAC,CAAC,SAAS,UAAU,IAAI,IAAI,CAC/D,CAAC,EACD,0BAA0B,CAAC,CAAC,CAAC,CAC9B,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,UAAU,IAAI,IAAI,CAC3D,CAAC,EACD,0BAA0B,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAClD,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,4BAA4B,GAAG,IAAI,CAC7C,UAAU,EACV,OAAO,CAAC,MAAM,UAAU,EAAE,aAAa,CAAC,CACzC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,UAAU,IAAI,IAAI,CAC9D,iBAAiB,CAAC,CAAC,CAAC,EAClB,MAAM,UAAU,GAChB,0BAA0B,CAAC,CAAC,CAAC,GAC7B,cAAc,CAAC,CAAC,CAAC,GACjB,qBAAqB,CAAC,CAAC,CAAC,GACxB,gBAAgB,CAAC,CAAC,CAAC,CACtB,CAAC"}

package/dist/src/operations/utils/expressionBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expressionBuilder.d.ts","sourceRoot":"","sources":["../../../../src/operations/utils/expressionBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EACV,gBAAgB,EAGjB,MAAM,SAAS,CAAC;AAUjB;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,eAChB,eAAe,KAC1B,gBAyBF,CAAC"}
+{"version":3,"file":"expressionBuilder.d.ts","sourceRoot":"","sources":["../../../../src/operations/utils/expressionBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EACV,gBAAgB,EAGjB,MAAM,SAAS,CAAC;AAUjB;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,eAChB,eAAe,KAC1B,gBAoBF,CAAC"}

package/dist/src/operations/utils/expressionBuilder.js

@@ -10,12 +10,9 @@ const expressionBuilder = (tableAttrs) => {
     const sorted = sortAttributesByOperand(tableAttrs);
     const setExpression = buildUpdateSetExpression(sorted.set);
     const removeExpression = buildUpdateRemoveExpression(sorted.remove);
-    const hasSetOperation = Object.keys(setExpression.ExpressionAttributeValues).length > 0;
     return {
         // If the operation has only REMOVE actions, it will not have expression attribute values
-        ExpressionAttributeValues: hasSetOperation
-            ? setExpression.ExpressionAttributeValues
-            : undefined,
+        ExpressionAttributeValues: setExpression.ExpressionAttributeValues,
         ExpressionAttributeNames: {
             ...setExpression.ExpressionAttributeNames,
             ...removeExpression.ExpressionAttributeNames

package/dist/src/operations/utils/index.d.ts

@@ -1,4 +1,3 @@
-export { default as RelationshipTransactions } from "./RelationshipTransactions";
 export * from "./expressionBuilder";
 export * from "./types";
 export * from "./utils";

package/dist/src/operations/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/operations/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACjF,cAAc,qBAAqB,CAAC;AACpC,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/operations/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC"}