dyna-record 0.1.5 → 0.2.1

package/dist/src/operations/Create/Create.js

@@ -8,12 +8,22 @@ const dynamo_utils_1 = require("../../dynamo-utils");
 const utils_1 = require("../../utils");
 const OperationBase_1 = __importDefault(require("../OperationBase"));
 const utils_2 = require("../utils");
+const utils_3 = require("../../metadata/utils");
 /**
- * Represents the operation for creating a new entity in the database, including handling its attributes and any related entities' associations. It will handle de-normalizing data to support relationships
+ * Represents an operation to create a new entity record in DynamoDB, including all necessary
+ * denormalized relationship records. This ensures that "BelongsTo" and "HasMany" relationships
+ * are properly maintained at the time of entity creation.
  *
- * It encapsulates the logic required to translate entity attributes to a format suitable for DynamoDB, execute the creation transaction, and manage any relationships defined by the entity, such as "BelongsTo" or "HasMany" links.
+ * **What it does:**
+ * - Converts the given attributes into a DynamoDB-compatible format.
+ * - Inserts a new entity record, ensuring no duplicate primary key conflicts.
+ * - For each "BelongsTo" relationship that includes a foreign key:
+ *   - Verifies the referenced entity exists.
+ *   - Creates a denormalized link record in the related entity's partition.
+ * - If the entity's relationships imply additional denormalized records in its own partition,
+ *   those are also created after verifying the related entities exist.
  *
- * Only attributes defined on the model can be configured, and will be enforced via types and runtime schema validation.
+ * Only attributes defined on the entity model can be set, validated both at compile-time and runtime.
  *
  * @template T - The type of the entity being created, extending `DynaRecord`.
  */
@@ -23,11 +33,22 @@ class Create extends OperationBase_1.default {
         super(Entity);
         this.#transactionBuilder = new dynamo_utils_1.TransactWriteBuilder();
     }
-    // TODO I need to handle the error where this throws because an item already exists and throw a better error...
     /**
-     * Create an entity transaction, including relationship transactions (EX: Creating BelongsToLinks for HasMany, checking existence of relationships, etc)
-     * @param attributes
-     * @returns
+     * Executes the create operation.
+     *
+     * **What it does:**
+     * - Parses and validates the provided attributes against the entity schema.
+     * - Generates any required reserved attributes (like `id`, `createdAt`, and `updatedAt`).
+     * - Inserts the new entity record into DynamoDB, ensuring it doesn't already exist.
+     * - For each defined "BelongsTo" relationship, ensures the related entity exists and creates
+     *   a corresponding denormalized "link" record.
+     * - If the entity's creation implies that related records must also be denormalized into its own
+     *   partition (due to "BelongsTo" links), retrieves and inserts those link records.
+     *
+     * @param attributes - Attributes to initialize the new entity. Must be defined on the model and valid per schema constraints.
+     * @returns A promise that resolves to the newly created entity with all attributes, including automatically set fields.
+     * @throws If the entity already exists, a uniqueness violation error is raised.
+     * @throws If a required foreign key does not correspond to an existing entity, an error is raised.
      */
     async run(attributes) {
         const entityAttrs = this.entityMetadata.parseRawEntityDefinedAttributes(attributes);
@@ -35,18 +56,30 @@ class Create extends OperationBase_1.default {
         const entityData = { ...reservedAttrs, ...entityAttrs };
         const tableItem = (0, utils_1.entityToTableItem)(this.EntityClass, entityData);
         this.buildPutItemTransaction(tableItem, entityData.id);
-        await this.buildRelationshipTransactions(entityData);
+        this.buildBelongsToTransactions(entityData, tableItem);
+        // Attempt to fetch all belongs-to entities to properly create reverse denormalization links
+        const belongsToTableItems = await this.getBelongsToTableItems(entityData);
+        // If there are any belongs-to relationships, add the inverse link records into the new entity's partition
+        if (belongsToTableItems.length > 0) {
+            this.buildAddBelongsToLinkToSelfTransactions(reservedAttrs.id, belongsToTableItems);
+        }
         await this.#transactionBuilder.executeTransaction();
         return (0, utils_1.tableItemToEntity)(this.EntityClass, tableItem);
     }
     /**
-     * Builds the entity attributes
-     * @param attributes
-     * @returns
+     * Builds and returns entity attributes that must be reserved for system usage.
+     *
+     * **What it does:**
+     * - Generates a unique entity ID if the entity's schema does not specify an `id` field.
+     * - Sets `createdAt` and `updatedAt` to the current time.
+     * - Builds the partition and sort key values based on the entity's class and generated ID.
+     *
+     * @param entityAttrs - The user-provided entity attributes.
+     * @returns The combined attributes including all reserved fields.
+     * @private
      */
     buildReservedAttributes(entityAttrs) {
         const { idField } = this.entityMetadata;
-        // If the entity has has a custom id field use that, otherwise generate a uuid
         const id = idField === undefined
             ? (0, uuid_1.v4)()
             : entityAttrs[idField];
@@ -66,28 +99,144 @@ class Create extends OperationBase_1.default {
         return { ...keys, ...defaultAttrs };
     }
     /**
-     * Build the transaction for the parent entity Create item request
-     * @param tableItem
+     * Adds a "PutItem" transaction for the new entity record.
+     *
+     * **What it does:**
+     * - Ensures the primary key does not already exist, preventing duplication.
+     *
+     * @param tableItem - The DynamoDB table item for the entity to put.
+     * @param id - The unique identifier of the new entity.
+     * @private
      */
     buildPutItemTransaction(tableItem, id) {
         const { name: tableName } = this.tableMetadata;
         const putExpression = {
             TableName: tableName,
             Item: tableItem,
-            ConditionExpression: `attribute_not_exists(${this.partitionKeyAlias})` // Ensure item doesn't already exist
+            ConditionExpression: `attribute_not_exists(${this.partitionKeyAlias})`
         };
         this.#transactionBuilder.addPut(putExpression, `${this.EntityClass.name} with id: ${id} already exists`);
     }
     /**
-     * Build transaction items for associations
-     * @param entityData
+     * Adds "PutItem" transactions to create denormalized "BelongsTo" link records in the related entity's partitions.
+     *
+     * **What it does:**
+     * - For each "BelongsTo" relationship with a defined foreign key, checks that the related entity exists.
+     * - Inserts a "link" item into the related entity's partition to maintain denormalized relationships.
+     *
+     * @param entityData - The complete set of entity attributes for the new entity.
+     * @param tableItem - The main entity's DynamoDB table item.
+     * @private
      */
-    async buildRelationshipTransactions(entityData) {
-        const relationshipTransactions = new utils_2.RelationshipTransactions({
-            Entity: this.EntityClass,
-            transactionBuilder: this.#transactionBuilder
+    buildBelongsToTransactions(entityData, tableItem) {
+        const tableName = this.tableMetadata.name;
+        const relMetadata = this.entityMetadata.belongsToOrOwnedByRelationships;
+        for (const relMeta of relMetadata) {
+            const foreignKey = (0, utils_2.extractForeignKeyFromEntity)(relMeta, entityData);
+            if (foreignKey !== undefined) {
+                // Ensure referenced entity exists before linking
+                this.buildRelationshipExistsConditionTransaction(relMeta, foreignKey);
+                const key = (0, utils_2.buildBelongsToLinkKey)(this.EntityClass, entityData.id, relMeta, foreignKey);
+                this.#transactionBuilder.addPut({
+                    TableName: tableName,
+                    Item: { ...tableItem, ...key },
+                    ConditionExpression: `attribute_not_exists(${this.partitionKeyAlias})`
+                }, `${relMeta.target.name} with id: ${foreignKey} already has an associated ${this.EntityClass.name}`);
+            }
+        }
+    }
+    /**
+     * Retrieves the DynamoDB items for all entities that the new entity references via "BelongsTo" relationships.
+     *
+     * **What it does:**
+     * - For each "BelongsTo" relationship, queries DynamoDB for the related entity record.
+     * - Returns all found related items as an array.
+     * - If no relationships or no foreign keys are present, returns an empty array.
+     *
+     * @param entityData - The attributes of the entity being created.
+     * @returns A promise that resolves to an array of related DynamoDB items.
+     * @private
+     */
+    async getBelongsToTableItems(entityData) {
+        const { name: tableName } = this.tableMetadata;
+        const transactionBuilder = new dynamo_utils_1.TransactGetBuilder();
+        const relMetas = this.entityMetadata.relationships;
+        const belongsToRelMetas = Object.values(relMetas).filter(relMeta => (0, utils_3.isBelongsToRelationship)(relMeta));
+        belongsToRelMetas.forEach(relMeta => {
+            const fk = (0, utils_2.extractForeignKeyFromEntity)(relMeta, entityData);
+            if (fk !== undefined) {
+                transactionBuilder.addGet({
+                    TableName: tableName,
+                    Key: {
+                        [this.partitionKeyAlias]: relMeta.target.partitionKeyValue(fk),
+                        [this.sortKeyAlias]: relMeta.target.name
+                    }
+                });
+            }
+        });
+        if (transactionBuilder.hasTransactions()) {
+            const results = await transactionBuilder.executeTransaction();
+            return results.reduce((acc, res) => {
+                if (res.Item !== undefined)
+                    acc.push(res.Item);
+                return acc;
+            }, []);
+        }
+        return [];
+    }
+    /**
+     * Adds a condition check transaction to ensure that the entity referenced by a "BelongsTo" foreign key exists.
+     *
+     * **What it does:**
+     * - Checks the existence of the related entity before creating the link item.
+     * - If the related entity does not exist, the transaction will fail, preventing creation of dangling references.
+     *
+     * @param rel - The "BelongsTo" relationship metadata.
+     * @param relationshipId - The foreign key value referencing the related entity.
+     * @private
+     */
+    buildRelationshipExistsConditionTransaction(rel, relationshipId) {
+        const { name: tableName } = this.tableMetadata;
+        const errMsg = `${rel.target.name} with ID '${relationshipId}' does not exist`;
+        const conditionCheck = {
+            TableName: tableName,
+            Key: {
+                [this.partitionKeyAlias]: rel.target.partitionKeyValue(relationshipId),
+                [this.sortKeyAlias]: rel.target.name
+            },
+            ConditionExpression: `attribute_exists(${this.partitionKeyAlias})`
+        };
+        this.#transactionBuilder.addConditionCheck(conditionCheck, errMsg);
+    }
+    /**
+     * For each related entity referenced by a "BelongsTo" relationship, insert a denormalized copy of that entity
+     * into the new entity's partition. This maintains a consistent, denormalized view of relationships.
+     *
+     * **What it does:**
+     * - Adds "PutItem" operations to create link records in the newly created entity's partition.
+     * - Ensures these link records don't already exist.
+     *
+     * @param entityId - The newly created entity's ID.
+     * @param belongsToTableItems - The table items representing each related "BelongsTo" entity.
+     * @private
+     */
+    buildAddBelongsToLinkToSelfTransactions(entityId, belongsToTableItems) {
+        const pk = this.EntityClass.partitionKeyValue(entityId);
+        const typeAlias = this.tableMetadata.defaultAttributes.type.alias;
+        belongsToTableItems.forEach(tableItem => {
+            const relationshipType = tableItem[typeAlias];
+            const key = {
+                [this.partitionKeyAlias]: pk,
+                [this.sortKeyAlias]: relationshipType
+            };
+            this.#transactionBuilder.addPut({
+                TableName: this.tableMetadata.name,
+                Item: { ...tableItem, ...key },
+                ConditionExpression: `attribute_not_exists(${this.partitionKeyAlias})`
+            }, 
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+            `${this.EntityClass.name} already has an associated ${relationshipType}`);
         });
-        await relationshipTransactions.build(entityData);
     }
 }
 exports.default = Create;

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

@@ -1,10 +1,10 @@
-import DynaRecord from "../../DynaRecord";
+import type DynaRecord from "../../DynaRecord";
 import type { EntityClass } from "../../types";
 import OperationBase from "../OperationBase";
 /**
  * Implements the operation for deleting an entity and its related data from the database within the ORM framework.
  *
- * Delete an entity, everything in its partition, BelongsToLinks and nullifies ForeignKeys on attributes that BelongTo it
+ * Delete an entity, everything in its partition, denormalized records and nullifies ForeignKeys on attributes that BelongTo it
  * If the foreign key is non nullable than it will throw a NullConstraintViolationError
  *
  * The `Delete` operation supports complex scenarios, such as deleting related entities in "BelongsTo" relationships, nullifying or removing foreign keys to maintain data integrity, and handling many-to-many relationships through join tables.
@@ -18,21 +18,38 @@ declare class Delete<T extends DynaRecord> extends OperationBase<T> {
      * Delete an item by id
      *   - Deletes the given entity
      *   - Deletes each item in the entity's partition
-     *   - For each item in the entity's partition which is of type 'BelongsToLink' it:
+     *   - For each item in the entity's partition which is a denormalized record it:
      *     - Will nullify the associated relationship's ForeignKey attribute if the attribute is nullable
      * @param id
      */
     run(id: string): Promise<void>;
     /**
-     * Deletes an item
-     * @param item
+     * Prefetch the item being deleted including items in its partition from denormalized associated records
+     * @param id
+     * @returns - The item and its associated links denormalized
+     */
+    private preFetch;
+    /**
+     * Returns true if the linked entity needs to have a foreign key nullified
+     * @param relMeta
+     * @returns
+     */
+    private doesEntityNeedForeignKeyNullified;
+    /**
+     * Delete the entity and denormalized links from BelongsTo relationships
+     * @param self
+     */
+    private buildDeleteSelfTransactions;
+    /**
+     * Deletes an item when given the table keys
+     * @param keys - The key to delete representing the table keys, as opposed to the entities keys
      */
     private buildDeleteItemTransaction;
     /**
-     * If the item has a JoinTable entry (is part of HasAndBelongsToMany relationship) then delete both JoinTable entries
-     * @param item - BelongsToLink from HasAndBelongsToMany relationship
+     * Deletes an item when given the keys of the entity. Converts the keys to the table alias
+     * @param keys - The key to delete representing the entity keys, as opposed to the table keys
      */
-    private buildDeleteJoinTableLinkTransaction;
+    private buildDeleteEntityTransaction;
     /**
      * If the item being deleted has a foreign key reference, nullify the associated relationship's ForeignKey attribute
      * If the ForeignKey is non nullable than it throws a NullConstraintViolationError
@@ -46,29 +63,21 @@ declare class Delete<T extends DynaRecord> extends OperationBase<T> {
      */
     private buildDeleteAssociatedBelongsTransaction;
     /**
-     * Deletes associated BelongsToLink for a BelongsTo HasMany relationship
-     * @param relMeta
-     * @param entityId
-     * @param foreignKeyValue
-     */
-    private buildDeleteBelongsToHasManyTransaction;
-    /**
-     * Deletes associated BelongsToLink for a BelongsTo HasOne relationship
-     * @param relMeta
-     * @param foreignKeyValue
+     * If the item has a JoinTable entry (is part of HasAndBelongsToMany relationship) then delete both JoinTable entries
+     * @param item - Denormalized record from HasAndBelongsToMany relationship
      */
-    private buildDeleteBelongsToHasOneTransaction;
+    private buildDeleteJoinTableLinkTransaction;
     /**
-     * Type guard to check if the item being evaluated is the currentClass
-     * @param item
-     * @returns
+     * If the entity being deleted is owned by another entity via a unidirectional relationship, delete the denormalized records
+     * @param self - The entity being deleted
      */
-    private isEntityClass;
+    private buildDeleteOwnedByRelationships;
     /**
      * Track validation errors and throw AggregateError after all validations have been run
      * @param err
      */
     private trackValidationError;
+    private buildKeyObject;
 }
 export default Delete;
 //# sourceMappingURL=Delete.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Delete.d.ts","sourceRoot":"","sources":["../../../../src/operations/Delete/Delete.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,kBAAkB,CAAC;AAc1C,OAAO,KAAK,EAAE,WAAW,EAAsB,MAAM,aAAa,CAAC;AAEnE,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAI7C;;;;;;;;;GASG;AACH,cAAM,MAAM,CAAC,CAAC,SAAS,UAAU,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC;;gBAS7C,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;IAiBlC;;;;;;;OAOG;IACU,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAyC3C;;;OAGG;IACH,OAAO,CAAC,0BAA0B;IAmBlC;;;OAGG;IACH,OAAO,CAAC,mCAAmC;IAoB3C;;;;OAIG;IACH,OAAO,CAAC,iCAAiC;IA0CzC;;;;OAIG;IACH,OAAO,CAAC,uCAAuC;IA0B/C;;;;;OAKG;IACH,OAAO,CAAC,sCAAsC;IAkB9C;;;;OAIG;IACH,OAAO,CAAC,qCAAqC;IAiB7C;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAIrB;;;OAGG;IACH,OAAO,CAAC,oBAAoB;CAG7B;AAED,eAAe,MAAM,CAAC"}
+{"version":3,"file":"Delete.d.ts","sourceRoot":"","sources":["../../../../src/operations/Delete/Delete.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAY/C,OAAO,KAAK,EAEV,WAAW,EAEZ,MAAM,aAAa,CAAC;AAErB,OAAO,aAAa,MAAM,kBAAkB,CAAC;AA2B7C;;;;;;;;;GASG;AACH,cAAM,MAAM,CAAC,CAAC,SAAS,UAAU,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC;;gBAS7C,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;IAiBlC;;;;;;;OAOG;IACU,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgC3C;;;;OAIG;YACW,QAAQ;IA+BtB;;;;OAIG;IACH,OAAO,CAAC,iCAAiC;IASzC;;;OAGG;IACH,OAAO,CAAC,2BAA2B;IAOnC;;;OAGG;IACH,OAAO,CAAC,0BAA0B;IAalC;;;OAGG;IACH,OAAO,CAAC,4BAA4B;IAkBpC;;;;OAIG;YACW,iCAAiC;IA2B/C;;;;OAIG;IACH,OAAO,CAAC,uCAAuC;IA2B/C;;;OAGG;IACH,OAAO,CAAC,mCAAmC;IAiB3C;;;OAGG;IACH,OAAO,CAAC,+BAA+B;IAqBvC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAI5B,OAAO,CAAC,cAAc;CAcvB;AAED,eAAe,MAAM,CAAC"}

package/dist/src/operations/Delete/Delete.js

@@ -3,19 +3,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const DynaRecord_1 = __importDefault(require("../../DynaRecord"));
 const dynamo_utils_1 = require("../../dynamo-utils");
 const errors_1 = require("../../errors");
 const metadata_1 = __importDefault(require("../../metadata"));
 const utils_1 = require("../../metadata/utils");
-const relationships_1 = require("../../relationships");
 const utils_2 = require("../../utils");
 const OperationBase_1 = __importDefault(require("../OperationBase"));
+const Update_1 = require("../Update");
 const utils_3 = require("../utils");
 /**
  * Implements the operation for deleting an entity and its related data from the database within the ORM framework.
  *
- * Delete an entity, everything in its partition, BelongsToLinks and nullifies ForeignKeys on attributes that BelongTo it
+ * Delete an entity, everything in its partition, denormalized records and nullifies ForeignKeys on attributes that BelongTo it
  * If the foreign key is non nullable than it will throw a NullConstraintViolationError
  *
  * The `Delete` operation supports complex scenarios, such as deleting related entities in "BelongsTo" relationships, nullifying or removing foreign keys to maintain data integrity, and handling many-to-many relationships through join tables.
@@ -45,33 +44,23 @@ class Delete extends OperationBase_1.default {
      * Delete an item by id
      *   - Deletes the given entity
      *   - Deletes each item in the entity's partition
-     *   - For each item in the entity's partition which is of type 'BelongsToLink' it:
+     *   - For each item in the entity's partition which is a denormalized record it:
      *     - Will nullify the associated relationship's ForeignKey attribute if the attribute is nullable
      * @param id
      */
     async run(id) {
-        const items = await this.EntityClass.query(id);
-        if (items.length === 0) {
-            throw new errors_1.NotFoundError(`Item does not exist: ${id}`);
-        }
-        for (const item of items) {
-            if (item.id === id && this.isEntityClass(item)) {
-                this.buildDeleteItemTransaction(item, {
-                    errorMessage: `Failed to delete ${this.EntityClass.name} with Id: ${id}`
-                });
-                this.buildDeleteAssociatedBelongsTransaction(id, item);
-            }
-            if (item instanceof relationships_1.BelongsToLink) {
-                this.buildDeleteItemTransaction(item, {
-                    errorMessage: `Failed to delete BelongsToLink with keys: ${JSON.stringify({
-                        [this.#partitionKeyField]: item[this.#partitionKeyField],
-                        [this.#sortKeyField]: item[this.#sortKeyField]
-                    })}`
-                });
-                this.buildNullifyForeignKeyTransaction(item);
-                this.buildDeleteJoinTableLinkTransaction(item);
-            }
-        }
+        const preFetchRes = await this.preFetch(id);
+        this.buildDeleteSelfTransactions(preFetchRes.self);
+        preFetchRes.linkedEntities.forEach(item => {
+            this.buildDeleteEntityTransaction(item, {
+                errorMessage: `Failed to delete denormalized record with keys: ${JSON.stringify(this.buildKeyObject(item, this.#partitionKeyField, this.#sortKeyField))}`
+            });
+            this.buildDeleteJoinTableLinkTransaction(item);
+        });
+        this.buildDeleteOwnedByRelationships(preFetchRes.self);
+        await Promise.all(preFetchRes.linkedEntitiesWithFkRef.map(async (entity) => {
+            await this.buildNullifyForeignKeyTransaction(entity);
+        }));
         if (this.#validationErrors.length === 0) {
             await this.#transactionBuilder.executeTransaction();
         }
@@ -80,35 +69,75 @@ class Delete extends OperationBase_1.default {
         }
     }
     /**
-     * Deletes an item
-     * @param item
+     * Prefetch the item being deleted including items in its partition from denormalized associated records
+     * @param id
+     * @returns - The item and its associated links denormalized
+     */
+    async preFetch(id) {
+        const items = await this.EntityClass.query(id);
+        const prefetchResult = items.reduce((acc, item) => {
+            const isItemSelf = item.id === id && item instanceof this.EntityClass;
+            if (isItemSelf) {
+                acc.self = item;
+            }
+            else if (this.doesEntityNeedForeignKeyNullified(item)) {
+                acc.linkedEntitiesWithFkRef.push(item);
+            }
+            else {
+                acc.linkedEntities.push(item);
+            }
+            return acc;
+        }, { linkedEntities: [], linkedEntitiesWithFkRef: [] });
+        if (prefetchResult.self === undefined) {
+            throw new errors_1.NotFoundError(`Item does not exist: ${id}`);
+        }
+        return {
+            self: prefetchResult.self,
+            linkedEntities: prefetchResult.linkedEntities,
+            linkedEntitiesWithFkRef: prefetchResult.linkedEntitiesWithFkRef
+        };
+    }
+    /**
+     * Returns true if the linked entity needs to have a foreign key nullified
+     * @param relMeta
+     * @returns
+     */
+    doesEntityNeedForeignKeyNullified(linkedEntity) {
+        const relMeta = this.#relationsLookup[linkedEntity.type];
+        return (!(0, utils_1.isBelongsToRelationship)(relMeta) &&
+            (0, utils_1.isRelationshipMetadataWithForeignKey)(relMeta));
+    }
+    /**
+     * Delete the entity and denormalized links from BelongsTo relationships
+     * @param self
+     */
+    buildDeleteSelfTransactions(self) {
+        this.buildDeleteEntityTransaction(self, {
+            errorMessage: `Failed to delete ${this.EntityClass.name} with Id: ${self.id}`
+        });
+        this.buildDeleteAssociatedBelongsTransaction(self.id, self);
+    }
+    /**
+     * Deletes an item when given the table keys
+     * @param keys - The key to delete representing the table keys, as opposed to the entities keys
      */
-    buildDeleteItemTransaction(item, options) {
-        const pkField = this.#partitionKeyField;
-        const skField = this.#sortKeyField;
+    buildDeleteItemTransaction(keys, options) {
         this.#transactionBuilder.addDelete({
             TableName: this.#tableName,
-            Key: {
-                [this.partitionKeyAlias]: item[pkField],
-                [this.sortKeyAlias]: item[skField]
-            }
+            Key: keys
         }, options.errorMessage);
     }
     /**
-     * If the item has a JoinTable entry (is part of HasAndBelongsToMany relationship) then delete both JoinTable entries
-     * @param item - BelongsToLink from HasAndBelongsToMany relationship
+     * Deletes an item when given the keys of the entity. Converts the keys to the table alias
+     * @param keys - The key to delete representing the entity keys, as opposed to the table keys
      */
-    buildDeleteJoinTableLinkTransaction(item) {
-        const relMeta = this.#relationsLookup[item.foreignEntityType];
-        if ((0, utils_1.isHasAndBelongsToManyRelationship)(relMeta)) {
-            // Inverse the keys to delete the other JoinTable entry
-            const belongsToLinksKeys = {
-                [this.#partitionKeyField]: item[this.#sortKeyField],
-                [this.#sortKeyField]: item[this.#partitionKeyField]
-            };
-            this.buildDeleteItemTransaction(belongsToLinksKeys, {
-                errorMessage: `Failed to delete BelongsToLink with keys: ${JSON.stringify(belongsToLinksKeys)}`
-            });
+    buildDeleteEntityTransaction(keys, options) {
+        if ((0, utils_2.isKeyOfObject)(keys, this.#partitionKeyField) &&
+            (0, utils_2.isKeyOfObject)(keys, this.#sortKeyField)) {
+            this.buildDeleteItemTransaction({
+                [this.partitionKeyAlias]: keys[this.#partitionKeyField],
+                [this.sortKeyAlias]: keys[this.#sortKeyField]
+            }, options);
         }
     }
     /**
@@ -116,28 +145,18 @@ class Delete extends OperationBase_1.default {
      * If the ForeignKey is non nullable than it throws a NullConstraintViolationError
      * @param item
      */
-    buildNullifyForeignKeyTransaction(item) {
-        const relMeta = this.#relationsLookup[item.foreignEntityType];
+    async buildNullifyForeignKeyTransaction(item) {
+        const relMeta = this.#relationsLookup[item.type];
         if ((0, utils_1.isRelationshipMetadataWithForeignKey)(relMeta)) {
             const entityAttrs = metadata_1.default.getEntityAttributes(relMeta.target.name);
             const attrMeta = Object.values(entityAttrs).find(attr => attr.name === relMeta.foreignKey);
             if (attrMeta?.nullable === false) {
                 this.trackValidationError(new errors_1.NullConstraintViolationError(`Cannot set ${relMeta.target.name} with id: '${item.id}' attribute '${relMeta.foreignKey}' to null`));
             }
-            const tableKeys = (0, utils_2.entityToTableItem)(this.EntityClass, {
-                [this.#partitionKeyField]: relMeta.target.partitionKeyValue(item.foreignKey),
-                [this.#sortKeyField]: relMeta.target.name
-            });
-            const tableAttrs = (0, utils_2.entityToTableItem)(relMeta.target, {
-                [relMeta.foreignKey]: null
-            });
-            const expression = (0, utils_3.expressionBuilder)(tableAttrs);
-            this.#transactionBuilder.addUpdate({
-                TableName: this.#tableName,
-                Key: tableKeys,
-                UpdateExpression: expression.UpdateExpression,
-                ExpressionAttributeNames: expression.ExpressionAttributeNames
-            }, `Failed to remove foreign key attribute from ${relMeta.target.name} with Id: ${item.foreignKey}`);
+            else {
+                const op = new Update_1.UpdateDryRun(relMeta.target, this.#transactionBuilder);
+                await op.run(item.id, { [relMeta.foreignKey]: null });
+            }
         }
     }
     /**
@@ -150,52 +169,41 @@ class Delete extends OperationBase_1.default {
             if ((0, utils_2.isKeyOfObject)(item, relMeta.foreignKey) &&
                 item[relMeta.foreignKey] !== undefined) {
                 const foreignKeyValue = item[relMeta.foreignKey];
-                if ((0, utils_1.doesEntityBelongToRelAsHasMany)(this.EntityClass, relMeta)) {
-                    this.buildDeleteBelongsToHasManyTransaction(relMeta, entityId, foreignKeyValue);
-                }
-                if ((0, utils_1.doesEntityBelongToRelAsHasOne)(this.EntityClass, relMeta)) {
-                    this.buildDeleteBelongsToHasOneTransaction(relMeta, foreignKeyValue);
-                }
+                const belongsToLinksKeys = (0, utils_3.buildBelongsToLinkKey)(this.EntityClass, entityId, relMeta, foreignKeyValue);
+                this.buildDeleteItemTransaction(belongsToLinksKeys, {
+                    errorMessage: `Failed to delete denormalized record with keys: ${JSON.stringify(belongsToLinksKeys)}`
+                });
             }
         });
     }
     /**
-     * Deletes associated BelongsToLink for a BelongsTo HasMany relationship
-     * @param relMeta
-     * @param entityId
-     * @param foreignKeyValue
+     * If the item has a JoinTable entry (is part of HasAndBelongsToMany relationship) then delete both JoinTable entries
+     * @param item - Denormalized record from HasAndBelongsToMany relationship
      */
-    buildDeleteBelongsToHasManyTransaction(relMeta, entityId, foreignKeyValue) {
-        const belongsToLinksKeys = {
-            [this.#partitionKeyField]: relMeta.target.partitionKeyValue(foreignKeyValue),
-            [this.#sortKeyField]: this.EntityClass.partitionKeyValue(entityId)
-        };
-        this.buildDeleteItemTransaction(belongsToLinksKeys, {
-            errorMessage: `Failed to delete BelongsToLink with keys: ${JSON.stringify(belongsToLinksKeys)}`
-        });
+    buildDeleteJoinTableLinkTransaction(item) {
+        const relMeta = this.#relationsLookup[item.type];
+        if ((0, utils_1.isHasAndBelongsToManyRelationship)(relMeta)) {
+            const belongsToLinksKeys = this.buildKeyObject(item, this.#sortKeyField, this.#partitionKeyField);
+            this.buildDeleteEntityTransaction(belongsToLinksKeys, {
+                errorMessage: `Failed to delete denormalized record with keys: ${JSON.stringify(belongsToLinksKeys)}`
+            });
+        }
     }
     /**
-     * Deletes associated BelongsToLink for a BelongsTo HasOne relationship
-     * @param relMeta
-     * @param foreignKeyValue
+     * If the entity being deleted is owned by another entity via a unidirectional relationship, delete the denormalized records
+     * @param self - The entity being deleted
      */
-    buildDeleteBelongsToHasOneTransaction(relMeta, foreignKeyValue) {
-        const belongsToLinksKeys = {
-            [this.#partitionKeyField]: relMeta.target.partitionKeyValue(foreignKeyValue),
-            [this.#sortKeyField]: this.EntityClass.name
-        };
-        this.buildDeleteItemTransaction(belongsToLinksKeys, {
-            errorMessage: `Failed to delete BelongsToLink with keys: ${JSON.stringify(belongsToLinksKeys)}`
+    buildDeleteOwnedByRelationships(self) {
+        this.entityMetadata.ownedByRelationships.forEach(ownedByRelMeta => {
+            if ((0, utils_2.isKeyOfObject)(self, ownedByRelMeta.foreignKey)) {
+                const fkValue = self[ownedByRelMeta.foreignKey];
+                const keys = (0, utils_3.buildBelongsToLinkKey)(this.EntityClass, self.id, ownedByRelMeta, fkValue);
+                this.buildDeleteItemTransaction(keys, {
+                    errorMessage: `Failed to delete denormalized record with keys: ${JSON.stringify(keys)}`
+                });
+            }
         });
     }
-    /**
-     * Type guard to check if the item being evaluated is the currentClass
-     * @param item
-     * @returns
-     */
-    isEntityClass(item) {
-        return item instanceof DynaRecord_1.default;
-    }
     /**
      * Track validation errors and throw AggregateError after all validations have been run
      * @param err
@@ -203,5 +211,14 @@ class Delete extends OperationBase_1.default {
     trackValidationError(err) {
         this.#validationErrors.push(err);
     }
+    buildKeyObject(item, pkField, skField) {
+        if ((0, utils_2.isKeyOfObject)(item, pkField) && (0, utils_2.isKeyOfObject)(item, skField)) {
+            return {
+                [this.#partitionKeyField]: item[pkField],
+                [this.#sortKeyField]: item[skField]
+            };
+        }
+        throw new Error("Invalid keys");
+    }
 }
 exports.default = Delete;

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

@@ -1,7 +1,4 @@
-import type DynaRecord from "../../DynaRecord";
-import { type QueryResult } from "../Query";
 export interface DeleteOptions {
     errorMessage: string;
 }
-export type ItemKeys<T extends DynaRecord> = Partial<QueryResult<T>>;
 //# sourceMappingURL=types.d.ts.map