dyna-record 0.1.4 → 0.2.0

package/dist/src/metadata/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/metadata/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EACnB,qBAAqB,EACrB,kBAAkB,EAClB,+BAA+B,EAChC,MAAM,GAAG,CAAC;AACX,OAAO,KAAK,UAAU,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,SAAS,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C;;GAEG;AACH,eAAO,MAAM,qBAAqB,QAC3B,oBAAoB,+BAG1B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,QAC7B,oBAAoB,iCAG1B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,QAC1B,oBAAoB,8BAG1B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iCAAiC,QACvC,oBAAoB,2CAG1B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,oCAAoC,QAC1C,oBAAoB,8CAG1B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,sDAEnC,qBAAqB,KACzB,OAMF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B,sDAEpC,qBAAqB,KACzB,OAMF,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/metadata/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EACnB,qBAAqB,EACrB,kBAAkB,EAClB,+BAA+B,EAChC,MAAM,GAAG,CAAC;AACX,OAAO,KAAK,UAAU,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,SAAS,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C;;GAEG;AACH,eAAO,MAAM,qBAAqB,QAC3B,oBAAoB,KACxB,GAAG,IAAI,mBAET,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,QAC7B,oBAAoB,KACxB,GAAG,IAAI,qBAET,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,QAC1B,oBAAoB,KACxB,GAAG,IAAI,kBAET,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iCAAiC,QACvC,oBAAoB,KACxB,GAAG,IAAI,+BAET,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,oCAAoC,QAC1C,oBAAoB,KACxB,GAAG,IAAI,kCAET,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,GAAI,CAAC,SAAS,UAAU,UACxD,WAAW,CAAC,CAAC,CAAC,OACjB,qBAAqB,KACzB,OAMF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B,GAAI,CAAC,SAAS,UAAU,UACzD,WAAW,CAAC,CAAC,CAAC,OACjB,qBAAqB,KACzB,OAMF,CAAC"}

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

@@ -2,13 +2,22 @@ import type DynaRecord from "../../DynaRecord";
 import type { EntityClass } from "../../types";
 import OperationBase from "../OperationBase";
 import type { CreateOptions } from "./types";
-import { type EntityAttributes } from "../types";
+import { type EntityAttributesOnly } from "../types";
 /**
- * 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`.
  */
@@ -16,27 +25,97 @@ declare class Create<T extends DynaRecord> extends OperationBase<T> {
     #private;
     constructor(Entity: EntityClass<T>);
     /**
-     * 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.
      */
-    run(attributes: CreateOptions<T>): Promise<EntityAttributes<T>>;
+    run(attributes: CreateOptions<T>): Promise<EntityAttributesOnly<T>>;
     /**
-     * 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
      */
     private buildReservedAttributes;
     /**
-     * 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
      */
     private buildPutItemTransaction;
     /**
-     * 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
      */
-    private buildRelationshipTransactions;
+    private buildBelongsToTransactions;
+    /**
+     * 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
+     */
+    private getBelongsToTableItems;
+    /**
+     * 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
+     */
+    private buildRelationshipExistsConditionTransaction;
+    /**
+     * 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
+     */
+    private buildAddBelongsToLinkToSelfTransactions;
 }
 export default Create;
 //# sourceMappingURL=Create.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Create.d.ts","sourceRoot":"","sources":["../../../../src/operations/Create/Create.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAE/C,OAAO,KAAK,EAAmB,WAAW,EAAE,MAAM,aAAa,CAAC;AAGhE,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAE7C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,EAEL,KAAK,gBAAgB,EACtB,MAAM,UAAU,CAAC;AAGlB;;;;;;;;GAQG;AACH,cAAM,MAAM,CAAC,CAAC,SAAS,UAAU,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC;;gBAG7C,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;IAKlC;;;;OAIG;IACU,GAAG,CAAC,UAAU,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;IAiB5E;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;IAsB/B;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAW/B;;;OAGG;YACW,6BAA6B;CAU5C;AAED,eAAe,MAAM,CAAC"}
+{"version":3,"file":"Create.d.ts","sourceRoot":"","sources":["../../../../src/operations/Create/Create.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAE/C,OAAO,KAAK,EAAmB,WAAW,EAAE,MAAM,aAAa,CAAC;AAOhE,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAE7C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,UAAU,CAAC;AAIlB;;;;;;;;;;;;;;;;;GAiBG;AACH,cAAM,MAAM,CAAC,CAAC,SAAS,UAAU,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC;;gBAG7C,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;IAKlC;;;;;;;;;;;;;;;;OAgBG;IACU,GAAG,CACd,UAAU,EAAE,aAAa,CAAC,CAAC,CAAC,GAC3B,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC;IA4BnC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,uBAAuB;IA8B/B;;;;;;;;;OASG;IACH,OAAO,CAAC,uBAAuB;IAiB/B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,0BAA0B;IAgClC;;;;;;;;;;;OAWG;YACW,sBAAsB;IAmCpC;;;;;;;;;;OAUG;IACH,OAAO,CAAC,2CAA2C;IAmBnD;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,uCAAuC;CA0BhD;AAED,eAAe,MAAM,CAAC"}

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

@@ -8,13 +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 metadata_1 = __importDefault(require("../../metadata"));
+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`.
  */
@@ -25,28 +34,55 @@ class Create extends OperationBase_1.default {
         this.#transactionBuilder = new dynamo_utils_1.TransactWriteBuilder();
     }
     /**
-     * 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 entityMeta = metadata_1.default.getEntity(this.EntityClass.name);
-        const entityAttrs = entityMeta.parseRawEntityDefinedAttributes(attributes);
-        const reservedAttrs = this.buildReservedAttributes();
+        const entityAttrs = this.entityMetadata.parseRawEntityDefinedAttributes(attributes);
+        const reservedAttrs = this.buildReservedAttributes(entityAttrs);
         const entityData = { ...reservedAttrs, ...entityAttrs };
         const tableItem = (0, utils_1.entityToTableItem)(this.EntityClass, entityData);
-        this.buildPutItemTransaction(tableItem);
-        await this.buildRelationshipTransactions(entityData);
+        this.buildPutItemTransaction(tableItem, entityData.id);
+        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() {
-        const id = (0, uuid_1.v4)();
+    buildReservedAttributes(entityAttrs) {
+        const { idField } = this.entityMetadata;
+        const id = idField === undefined
+            ? (0, uuid_1.v4)()
+            : entityAttrs[idField];
         const createdAt = new Date();
         const pk = this.tableMetadata.partitionKeyAttribute.name;
         const sk = this.tableMetadata.sortKeyAttribute.name;
@@ -63,28 +99,143 @@ 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) {
+    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.#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;
+        for (const relMeta of this.entityMetadata.belongsToRelationships) {
+            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,16 @@ 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
-     */
-    private buildDeleteBelongsToHasOneTransaction;
-    /**
-     * Type guard to check if the item being evaluated is the currentClass
-     * @param item
-     * @returns
+     * 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 isEntityClass;
+    private buildDeleteJoinTableLinkTransaction;
     /**
      * 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;IA8B3C;;;;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,oBAAoB;IAI5B,OAAO,CAAC,cAAc;CAcvB;AAED,eAAe,MAAM,CAAC"}