dyna-record 0.4.0 → 0.4.1

package/README.md

@@ -357,6 +357,25 @@ const grade: Grade = await Grade.create({
 });
 ```
 
+#### Skipping Referential Integrity Checks
+
+By default, when creating entities with foreign key references, dyna-record performs condition checks to ensure that referenced entities exist. This prevents creating entities with invalid foreign key references. However, in high-contention or high-throughput systems where the same foreign key may be referenced in parallel operations, these condition checks can fail due to transaction conflicts. In scenarios such as bulk imports or when you've already verified the references, you may want to skip these checks to prevent such failures.
+
+To skip referential integrity checks, pass an options object as the second parameter with `referentialIntegrityCheck: false`:
+
+```typescript
+const grade: Grade = await Grade.create(
+  {
+    gradeValue: "A+",
+    assignmentId: "123",
+    studentId: "456"
+  },
+  { referentialIntegrityCheck: false }
+);
+```
+
+**Note:** When `referentialIntegrityCheck` is set to `false`, the condition checks that verify foreign key references exist are skipped. This means you can create entities even if the referenced entities don't exist, which may lead to data integrity issues. Use this option with caution.
+
 #### Error handling
 
 The method is designed to throw errors under various conditions, such as transaction cancellation due to failed conditional checks. For instance, if you attempt to create a `Grade` for an `Assignment` that already has one, the method throws a [TransactionWriteFailedError](https://dyna-record.com/classes/TransactionWriteFailedError.html).
@@ -549,6 +568,31 @@ const updatedInstance = await petInstance.update({
 });
 ```
 
+#### Skipping Referential Integrity Checks
+
+By default, when updating entities with foreign key references, dyna-record performs condition checks to ensure that referenced entities exist. This prevents updating entities with invalid foreign key references. However, in high-contention or high-throughput systems where the same foreign key may be referenced in parallel operations, these condition checks can fail due to transaction conflicts. In scenarios such as bulk updates or when you've already verified the references, you may want to skip these checks to prevent such failures.
+
+To skip referential integrity checks, pass an options object as the third parameter with `referentialIntegrityCheck: false`:
+
+```typescript
+await PaymentMethod.update(
+  "123",
+  { customerId: "456" },
+  { referentialIntegrityCheck: false }
+);
+```
+
+For instance methods:
+
+```typescript
+const updatedInstance = await paymentMethodInstance.update(
+  { customerId: "456" },
+  { referentialIntegrityCheck: false }
+);
+```
+
+**Note:** When `referentialIntegrityCheck` is set to `false`, the condition checks that verify foreign key references exist are skipped. This means you can update entities even if the referenced entities don't exist, which may lead to data integrity issues. Use this option with caution.
+
 ### Delete
 
 [Docs](https://dyna-record.com/classes/default.html#delete)

package/dist/src/DynaRecord.d.ts

@@ -181,24 +181,36 @@ declare abstract class DynaRecord implements DynaRecordBase {
      */
     static query<T extends DynaRecord>(this: EntityClass<T>, key: IndexKeyConditions<T>, options: OptionsWithIndex): Promise<QueryResults<T>>;
     /**
-     * Create an entity. If foreign keys are included in the attributes then links will be demoralized accordingly
+     * Create an entity. If foreign keys are included in the attributes then links will be denormalized accordingly
      * @param attributes - Attributes of the model to create
+     * @param options - Optional operation options including referentialIntegrityCheck flag
      * @returns The new Entity
      *
+     * @example Basic usage
      * ```typescript
      * const newUser = await User.create({ name: "Alice", email: "alice@example.com", profileId: "123" });
      * ```
+     *
+     * @example With referential integrity check disabled
+     * ```typescript
+     * const newUser = await User.create(
+     *   { name: "Alice", email: "alice@example.com", profileId: "123" },
+     *   { referentialIntegrityCheck: false }
+     * );
+     * ```
      */
-    static create<T extends DynaRecord>(this: EntityClass<T>, attributes: CreateOptions<T>): Promise<ReturnType<Create<T>["run"]>>;
+    static create<T extends DynaRecord>(this: EntityClass<T>, attributes: CreateOptions<T>, options?: {
+        referentialIntegrityCheck?: boolean;
+    }): Promise<ReturnType<Create<T>["run"]>>;
     /**
-     * Update an entity. If foreign keys are included in the attribute then:
+     * Update an entity. If foreign keys are included in the attributes then:
      *   - Manages associated relationship links as needed
      *   - If the entity already had a foreign key relationship, then denormalized records will be deleted from each partition
      *     - If the foreign key is not nullable then a {@link NullConstraintViolationError} is thrown.
      *   - Validation errors will be thrown if the attribute being removed is not nullable
      * @param id - The id of the entity to update
      * @param attributes - Attributes to update
-     *
+     * @param options - Optional operation options including referentialIntegrityCheck flag
      *
      * @example Updating an entity.
      * ```typescript
@@ -209,12 +221,22 @@ declare abstract class DynaRecord implements DynaRecordBase {
      * ```typescript
      * await User.update("userId", { email: "newemail@example.com", someKey: null });
      * ```
+     *
+     * @example With referential integrity check disabled
+     * ```typescript
+     * await User.update(
+     *   "userId",
+     *   { email: "newemail@example.com", profileId: 789 },
+     *   { referentialIntegrityCheck: false }
+     * );
+     * ```
      */
-    static update<T extends DynaRecord>(this: EntityClass<T>, id: string, attributes: UpdateOptions<T>): Promise<void>;
+    static update<T extends DynaRecord>(this: EntityClass<T>, id: string, attributes: UpdateOptions<T>, options?: {
+        referentialIntegrityCheck?: boolean;
+    }): Promise<void>;
     /**
      *  Same as the static `update` method but on an instance. Returns the full updated instance
      *
-     *
      * @example Updating an entity.
      * ```typescript
      * const updatedInstance = await instance.update({ email: "newemail@example.com", profileId: 789 });
@@ -224,8 +246,18 @@ declare abstract class DynaRecord implements DynaRecordBase {
      * ```typescript
      * const updatedInstance = await instance.update({ email: "newemail@example.com", someKey: null });
      * ```
+     *
+     * @example With referential integrity check disabled
+     * ```typescript
+     * const updatedInstance = await instance.update(
+     *   { email: "newemail@example.com", profileId: 789 },
+     *   { referentialIntegrityCheck: false }
+     * );
+     * ```
      */
-    update<T extends this>(attributes: UpdateOptions<T>): Promise<EntityAttributesInstance<T>>;
+    update<T extends this>(attributes: UpdateOptions<T>, options?: {
+        referentialIntegrityCheck?: boolean;
+    }): Promise<EntityAttributesInstance<T>>;
     /**
      * Delete an entity by ID
      *   - Delete all denormalized records

package/dist/src/DynaRecord.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DynaRecord.d.ts","sourceRoot":"","sources":["../../src/DynaRecord.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"DynaRecord.d.ts","sourceRoot":"","sources":["../../src/DynaRecord.ts"],"names":[],"mappings":"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"}

package/dist/src/DynaRecord.js

@@ -145,27 +145,37 @@ let DynaRecord = (() => {
             return await op.run(key, options);
         }
         /**
-         * Create an entity. If foreign keys are included in the attributes then links will be demoralized accordingly
+         * Create an entity. If foreign keys are included in the attributes then links will be denormalized accordingly
          * @param attributes - Attributes of the model to create
+         * @param options - Optional operation options including referentialIntegrityCheck flag
          * @returns The new Entity
          *
+         * @example Basic usage
          * ```typescript
          * const newUser = await User.create({ name: "Alice", email: "alice@example.com", profileId: "123" });
          * ```
+         *
+         * @example With referential integrity check disabled
+         * ```typescript
+         * const newUser = await User.create(
+         *   { name: "Alice", email: "alice@example.com", profileId: "123" },
+         *   { referentialIntegrityCheck: false }
+         * );
+         * ```
          */
-        static async create(attributes) {
+        static async create(attributes, options) {
             const op = new operations_1.Create(this);
-            return await op.run(attributes);
+            return await op.run(attributes, options);
         }
         /**
-         * Update an entity. If foreign keys are included in the attribute then:
+         * Update an entity. If foreign keys are included in the attributes then:
          *   - Manages associated relationship links as needed
          *   - If the entity already had a foreign key relationship, then denormalized records will be deleted from each partition
          *     - If the foreign key is not nullable then a {@link NullConstraintViolationError} is thrown.
          *   - Validation errors will be thrown if the attribute being removed is not nullable
          * @param id - The id of the entity to update
          * @param attributes - Attributes to update
-         *
+         * @param options - Optional operation options including referentialIntegrityCheck flag
          *
          * @example Updating an entity.
          * ```typescript
@@ -176,15 +186,23 @@ let DynaRecord = (() => {
          * ```typescript
          * await User.update("userId", { email: "newemail@example.com", someKey: null });
          * ```
+         *
+         * @example With referential integrity check disabled
+         * ```typescript
+         * await User.update(
+         *   "userId",
+         *   { email: "newemail@example.com", profileId: 789 },
+         *   { referentialIntegrityCheck: false }
+         * );
+         * ```
          */
-        static async update(id, attributes) {
+        static async update(id, attributes, options) {
             const op = new operations_1.Update(this);
-            await op.run(id, attributes);
+            await op.run(id, attributes, options);
         }
         /**
          *  Same as the static `update` method but on an instance. Returns the full updated instance
          *
-         *
          * @example Updating an entity.
          * ```typescript
          * const updatedInstance = await instance.update({ email: "newemail@example.com", profileId: 789 });
@@ -194,11 +212,19 @@ let DynaRecord = (() => {
          * ```typescript
          * const updatedInstance = await instance.update({ email: "newemail@example.com", someKey: null });
          * ```
+         *
+         * @example With referential integrity check disabled
+         * ```typescript
+         * const updatedInstance = await instance.update(
+         *   { email: "newemail@example.com", profileId: 789 },
+         *   { referentialIntegrityCheck: false }
+         * );
+         * ```
          */
-        async update(attributes) {
+        async update(attributes, options) {
             const InstanceClass = this.constructor;
             const op = new operations_1.Update(InstanceClass);
-            const updatedAttributes = await op.run(this.id, attributes);
+            const updatedAttributes = await op.run(this.id, attributes, options);
             const clone = structuredClone(this);
             // Update the current instance with new attributes
             Object.assign(clone, updatedAttributes);

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

@@ -1,7 +1,7 @@
 import type DynaRecord from "../../DynaRecord";
 import type { EntityClass } from "../../types";
 import OperationBase from "../OperationBase";
-import type { CreateOptions } from "./types";
+import type { CreateOptions, CreateOperationOptions } from "./types";
 import { type EntityAttributesOnly } from "../types";
 /**
  * Represents an operation to create a new entity record in DynamoDB, including all necessary
@@ -37,11 +37,12 @@ declare class Create<T extends DynaRecord> extends OperationBase<T> {
      *   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.
+     * @param options - Optional operation options including referentialIntegrityCheck flag.
      * @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.
+     * @throws If a required foreign key does not correspond to an existing entity, an error is raised (unless referentialIntegrityCheck is false).
      */
-    run(attributes: CreateOptions<T>): Promise<EntityAttributesOnly<T>>;
+    run(attributes: CreateOptions<T>, options?: CreateOperationOptions): Promise<EntityAttributesOnly<T>>;
     /**
      * Builds and returns entity attributes that must be reserved for system usage.
      *
@@ -75,6 +76,7 @@ declare class Create<T extends DynaRecord> extends OperationBase<T> {
      *
      * @param entityData - The complete set of entity attributes for the new entity.
      * @param tableItem - The main entity's DynamoDB table item.
+     * @param referentialIntegrityCheck - Whether to perform referential integrity checks.
      * @private
      */
     private buildBelongsToTransactions;
@@ -83,6 +85,8 @@ declare class Create<T extends DynaRecord> extends OperationBase<T> {
      * Ensures referenced entities exist even when denormalised access patterns are not defined.
      *
      * @param entityData - Attributes being persisted for the new entity.
+     * @param referentialIntegrityCheck - Whether to perform referential integrity checks.
+     * @private
      */
     private buildStandaloneForeignKeyConditionChecks;
     /**

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;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;IA6BnC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,uBAAuB;IA8B/B;;;;;;;;;OASG;IACH,OAAO,CAAC,uBAAuB;IAiB/B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,0BAA0B;IAkClC;;;;;OAKG;IACH,OAAO,CAAC,wCAAwC;IA8BhD;;;;;;;;;;;OAWG;YACW,sBAAsB;IAmCpC;;;;;;;;;;OAUG;IACH,OAAO,CAAC,2CAA2C;IAmBnD;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,uCAAuC;CA0BhD;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,sBAAsB,EAAE,MAAM,SAAS,CAAC;AACrE,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;;;;;;;;;;;;;;;;;OAiBG;IACU,GAAG,CACd,UAAU,EAAE,aAAa,CAAC,CAAC,CAAC,EAC5B,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC;IAuCnC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,uBAAuB;IA8B/B;;;;;;;;;OASG;IACH,OAAO,CAAC,uBAAuB;IAiB/B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,0BAA0B;IAqClC;;;;;;;OAOG;IACH,OAAO,CAAC,wCAAwC;IAkChD;;;;;;;;;;;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

@@ -46,18 +46,20 @@ class Create extends OperationBase_1.default {
      *   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.
+     * @param options - Optional operation options including referentialIntegrityCheck flag.
      * @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.
+     * @throws If a required foreign key does not correspond to an existing entity, an error is raised (unless referentialIntegrityCheck is false).
      */
-    async run(attributes) {
+    async run(attributes, options) {
+        const referentialIntegrityCheck = options?.referentialIntegrityCheck ?? true;
         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, entityData.id);
-        this.buildBelongsToTransactions(entityData, tableItem);
-        this.buildStandaloneForeignKeyConditionChecks(entityData);
+        this.buildBelongsToTransactions(entityData, tableItem, referentialIntegrityCheck);
+        this.buildStandaloneForeignKeyConditionChecks(entityData, referentialIntegrityCheck);
         // 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
@@ -127,16 +129,19 @@ class Create extends OperationBase_1.default {
      *
      * @param entityData - The complete set of entity attributes for the new entity.
      * @param tableItem - The main entity's DynamoDB table item.
+     * @param referentialIntegrityCheck - Whether to perform referential integrity checks.
      * @private
      */
-    buildBelongsToTransactions(entityData, tableItem) {
+    buildBelongsToTransactions(entityData, tableItem, referentialIntegrityCheck) {
         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);
+                if (referentialIntegrityCheck) {
+                    this.buildRelationshipExistsConditionTransaction(relMeta, foreignKey);
+                }
                 const key = (0, utils_2.buildBelongsToLinkKey)(this.EntityClass, entityData.id, relMeta, foreignKey);
                 this.#transactionBuilder.addPut({
                     TableName: tableName,
@@ -151,8 +156,13 @@ class Create extends OperationBase_1.default {
      * Ensures referenced entities exist even when denormalised access patterns are not defined.
      *
      * @param entityData - Attributes being persisted for the new entity.
+     * @param referentialIntegrityCheck - Whether to perform referential integrity checks.
+     * @private
      */
-    buildStandaloneForeignKeyConditionChecks(entityData) {
+    buildStandaloneForeignKeyConditionChecks(entityData, referentialIntegrityCheck) {
+        if (!referentialIntegrityCheck) {
+            return;
+        }
         const standaloneForeignKeys = this.entityMetadata.standaloneForeignKeyAttributes;
         for (const attrMeta of standaloneForeignKeys) {
             const target = attrMeta.foreignKeyTarget;

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

@@ -1,5 +1,17 @@
 import type DynaRecord from "../../DynaRecord";
 import type { EntityDefinedAttributes } from "../types";
+/**
+ * Options for create operations
+ */
+export interface CreateOperationOptions {
+    /**
+     * Whether to perform referential integrity checks for foreign key references.
+     * When `true` (default), condition checks are added to verify that referenced entities exist.
+     * When `false`, these condition checks are skipped, allowing creation even if foreign key references don't exist.
+     * @default true
+     */
+    referentialIntegrityCheck?: boolean;
+}
 /**
  * Entity attribute fields that can be set on create. Excludes that are managed by dyna-record
  */

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/operations/Create/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAExD;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,UAAU,IAAI,uBAAuB,CAAC,CAAC,CAAC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/operations/Create/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;;;OAKG;IACH,yBAAyB,CAAC,EAAE,OAAO,CAAC;CACrC;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,UAAU,IAAI,uBAAuB,CAAC,CAAC,CAAC,CAAC"}

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

@@ -1,7 +1,7 @@
 import type DynaRecord from "../../DynaRecord";
 import { TransactWriteBuilder } from "../../dynamo-utils";
 import OperationBase from "../OperationBase";
-import type { UpdatedAttributes, UpdateOptions } from "./types";
+import type { UpdatedAttributes, UpdateOptions, UpdateOperationOptions } from "./types";
 import type { EntityClass } from "../../types";
 /**
  * Represents an update operation for a DynaRecord-backed entity, handling both attribute updates and relationship consistency via denormalization.
@@ -35,10 +35,11 @@ declare class Update<T extends DynaRecord> extends OperationBase<T> {
      *
      * @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.
+     * @param options - Optional operation options including referentialIntegrityCheck flag.
      * @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.
      */
-    run(id: string, attributes: UpdateOptions<DynaRecord>): Promise<UpdatedAttributes<T>>;
+    run(id: string, attributes: UpdateOptions<DynaRecord>, options?: UpdateOperationOptions): Promise<UpdatedAttributes<T>>;
     protected commitTransaction(): Promise<void>;
     /**
      * BelongsToRelationship meta data and foreign key value pair for foreign keys being updated
@@ -50,6 +51,8 @@ declare class Update<T extends DynaRecord> extends OperationBase<T> {
      * Adds condition checks for standalone foreign keys present in the update payload to ensure the referenced records exist.
      *
      * @param attributes - Partial entity attributes supplied to the update call.
+     * @param referentialIntegrityCheck - Whether to perform referential integrity checks.
+     * @private
      */
     private addStandaloneForeignKeyConditionChecks;
     /**
@@ -114,6 +117,8 @@ declare class Update<T extends DynaRecord> extends OperationBase<T> {
      * @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.
+     * @param newBelongsToEntityLookup - Lookup of new belongs-to entities.
+     * @param referentialIntegrityCheck - Whether to perform referential integrity checks.
      * @private
      */
     private buildBelongsToTransactions;
@@ -141,6 +146,8 @@ declare class Update<T extends DynaRecord> extends OperationBase<T> {
      * @param newBelongsToEntityLookup
      * @param persistToSelfCondition
      * @param persistToSelfConditionErrMessage
+     * @param referentialIntegrityCheck - Whether to perform referential integrity checks.
+     * @private
      */
     private buildPutBelongsToLinkedRecords;
     /**
@@ -185,6 +192,8 @@ declare class Update<T extends DynaRecord> extends OperationBase<T> {
      * @param newForeignKey
      * @param oldForeignKey
      * @param newBelongsToEntityLookup
+     * @param referentialIntegrityCheck - Whether to perform referential integrity checks.
+     * @private
      */
     private updateForeignKeyTransactions;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"Update.d.ts","sourceRoot":"","sources":["../../../../src/operations/Update/Update.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAGL,oBAAoB,EACrB,MAAM,oBAAoB,CAAC;AAmB5B,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAChE,OAAO,KAAK,EAAmB,WAAW,EAAgB,MAAM,aAAa,CAAC;AA4D9E;;;;;;;;;;;;;;;;;GAiBG;AACH,cAAM,MAAM,CAAC,CAAC,SAAS,UAAU,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC;IACzD,SAAS,CAAC,QAAQ,CAAC,kBAAkB,EAAE,oBAAoB,CAAC;gBAG1D,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EACtB,kBAAkB,CAAC,EAAE,oBAAoB;IAO3C;;;;;;;;;;;;;OAaG;IACU,GAAG,CACd,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,aAAa,CAAC,UAAU,CAAC,GACpC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;cA6ChB,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IAIlD;;;;OAIG;IACH,OAAO,CAAC,uCAAuC;IAY/C;;;;OAIG;IACH,OAAO,CAAC,sCAAsC;IAgC9C;;;;;;;;;;;;;;;OAeG;YACW,QAAQ;IAsDtB;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB;IA4B7B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,mBAAmB;IAY3B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,0BAA0B;IAyBlC;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,0BAA0B;IAuDlC;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,iCAAiC;IAuBzC;;;;;;;;;;OAUG;IACH,OAAO,CAAC,8BAA8B;IA+BtC;;;;OAIG;IACH,OAAO,CAAC,0BAA0B;IAkBlC;;;;;OAKG;IACH,OAAO,CAAC,mCAAmC;IAsB3C;;;;;;;;OAQG;IACH,OAAO,CAAC,sCAAsC;IAqC9C;;;;;;;;;;OAUG;IACH,OAAO,CAAC,6BAA6B;IAuCrC;;;;;;;OAOG;IACH,OAAO,CAAC,4BAA4B;IA6BpC;;;;;;;;;;OAUG;IACH,OAAO,CAAC,6BAA6B;IAwBrC;;;;;;OAMG;IACH,OAAO,CAAC,gCAAgC;IAgBxC;;;OAGG;IACH,OAAO,CAAC,iCAAiC;CAU1C;AAED,eAAe,MAAM,CAAC"}
+{"version":3,"file":"Update.d.ts","sourceRoot":"","sources":["../../../../src/operations/Update/Update.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAGL,oBAAoB,EACrB,MAAM,oBAAoB,CAAC;AAmB5B,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EACV,iBAAiB,EACjB,aAAa,EACb,sBAAsB,EACvB,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAmB,WAAW,EAAgB,MAAM,aAAa,CAAC;AA4D9E;;;;;;;;;;;;;;;;;GAiBG;AACH,cAAM,MAAM,CAAC,CAAC,SAAS,UAAU,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC;IACzD,SAAS,CAAC,QAAQ,CAAC,kBAAkB,EAAE,oBAAoB,CAAC;gBAG1D,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EACtB,kBAAkB,CAAC,EAAE,oBAAoB;IAO3C;;;;;;;;;;;;;;OAcG;IACU,GAAG,CACd,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,aAAa,CAAC,UAAU,CAAC,EACrC,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;cAoDhB,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IAIlD;;;;OAIG;IACH,OAAO,CAAC,uCAAuC;IAY/C;;;;;;OAMG;IACH,OAAO,CAAC,sCAAsC;IAoC9C;;;;;;;;;;;;;;;OAeG;YACW,QAAQ;IAsDtB;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB;IA4B7B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,mBAAmB;IAY3B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,0BAA0B;IAyBlC;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,0BAA0B;IA0DlC;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,iCAAiC;IAuBzC;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,8BAA8B;IAkCtC;;;;OAIG;IACH,OAAO,CAAC,0BAA0B;IAkBlC;;;;;OAKG;IACH,OAAO,CAAC,mCAAmC;IAsB3C;;;;;;;;OAQG;IACH,OAAO,CAAC,sCAAsC;IAqC9C;;;;;;;;;;OAUG;IACH,OAAO,CAAC,6BAA6B;IAuCrC;;;;;;;;;OASG;IACH,OAAO,CAAC,4BAA4B;IAgCpC;;;;;;;;;;OAUG;IACH,OAAO,CAAC,6BAA6B;IAwBrC;;;;;;OAMG;IACH,OAAO,CAAC,gCAAgC;IAgBxC;;;OAGG;IACH,OAAO,CAAC,iCAAiC;CAU1C;AAED,eAAe,MAAM,CAAC"}

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

@@ -46,15 +46,17 @@ class Update extends OperationBase_1.default {
      *
      * @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.
+     * @param options - Optional operation options including referentialIntegrityCheck flag.
      * @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) {
+    async run(id, attributes, options) {
+        const referentialIntegrityCheck = options?.referentialIntegrityCheck ?? true;
         const entityMeta = metadata_1.default.getEntity(this.EntityClass.name);
         const entityAttrs = entityMeta.parseRawEntityDefinedAttributesPartial(attributes);
         const { updatedAttrs, expression } = this.buildUpdateMetadata(entityAttrs);
         this.buildUpdateItemTransaction(id, expression);
-        this.addStandaloneForeignKeyConditionChecks(entityAttrs);
+        this.addStandaloneForeignKeyConditionChecks(entityAttrs, referentialIntegrityCheck);
         // Only need to prefetch if the entity has relationships
         if (entityMeta.allRelationships.length > 0) {
             const belongsToRelMetaBeingUpdated = this.getBelongsToRelMetaAndKeyForUpdatedKeys(entityAttrs);
@@ -66,7 +68,7 @@ class Update extends OperationBase_1.default {
                 id
             };
             this.buildUpdateRelatedEntityLinks(id, preFetch.relatedEntities, expression);
-            this.buildBelongsToTransactions(preFetch.entityPreUpdate, updatedEntity, expression, preFetch.newBelongsToEntityLookup);
+            this.buildBelongsToTransactions(preFetch.entityPreUpdate, updatedEntity, expression, preFetch.newBelongsToEntityLookup, referentialIntegrityCheck);
         }
         await this.commitTransaction();
         return updatedAttrs;
@@ -91,8 +93,13 @@ class Update extends OperationBase_1.default {
      * Adds condition checks for standalone foreign keys present in the update payload to ensure the referenced records exist.
      *
      * @param attributes - Partial entity attributes supplied to the update call.
+     * @param referentialIntegrityCheck - Whether to perform referential integrity checks.
+     * @private
      */
-    addStandaloneForeignKeyConditionChecks(attributes) {
+    addStandaloneForeignKeyConditionChecks(attributes, referentialIntegrityCheck) {
+        if (!referentialIntegrityCheck) {
+            return;
+        }
         const standaloneForeignKeys = this.entityMetadata.standaloneForeignKeyAttributes;
         for (const attrMeta of standaloneForeignKeys) {
             const target = attrMeta.foreignKeyTarget;
@@ -258,9 +265,11 @@ class Update extends OperationBase_1.default {
      * @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.
+     * @param newBelongsToEntityLookup - Lookup of new belongs-to entities.
+     * @param referentialIntegrityCheck - Whether to perform referential integrity checks.
      * @private
      */
-    buildBelongsToTransactions(entityPreUpdate, updatedEntity, updateExpression, newBelongsToEntityLookup) {
+    buildBelongsToTransactions(entityPreUpdate, updatedEntity, updateExpression, newBelongsToEntityLookup, referentialIntegrityCheck) {
         const entityId = entityPreUpdate.id;
         const relMetas = this.entityMetadata.belongsToOrOwnedByRelationships;
         for (const relMeta of relMetas) {
@@ -273,13 +282,13 @@ class Update extends OperationBase_1.default {
                 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}`);
+                    this.buildPutBelongsToLinkedRecords(updatedEntity, relMeta, foreignKey, newBelongsToEntityLookup, "attribute_not_exists", `${this.EntityClass.name} already has an associated ${relMeta.target.name}`, referentialIntegrityCheck);
                 }
                 else if (isRemovingForeignKey) {
                     this.removeForeignKeysTransactions(entityId, relMeta, oldFk);
                 }
                 else if (isUpdatingForeignKey) {
-                    this.updateForeignKeyTransactions(updatedEntity, relMeta, foreignKey, oldFk, newBelongsToEntityLookup);
+                    this.updateForeignKeyTransactions(updatedEntity, relMeta, foreignKey, oldFk, newBelongsToEntityLookup, referentialIntegrityCheck);
                 }
                 else if (foreignKey !== null) {
                     this.buildUpdateBelongsToLinkedRecords(entityId, relMeta, foreignKey, updateExpression);
@@ -320,10 +329,14 @@ class Update extends OperationBase_1.default {
      * @param newBelongsToEntityLookup
      * @param persistToSelfCondition
      * @param persistToSelfConditionErrMessage
+     * @param referentialIntegrityCheck - Whether to perform referential integrity checks.
+     * @private
      */
-    buildPutBelongsToLinkedRecords(updatedEntity, relMeta, foreignKey, newBelongsToEntityLookup, persistToSelfCondition, persistToSelfConditionErrMessage) {
+    buildPutBelongsToLinkedRecords(updatedEntity, relMeta, foreignKey, newBelongsToEntityLookup, persistToSelfCondition, persistToSelfConditionErrMessage, referentialIntegrityCheck = true) {
         // Ensure that the new foreign key is valid and exists
-        this.buildEntityExistsCondition(relMeta, foreignKey);
+        if (referentialIntegrityCheck) {
+            this.buildEntityExistsCondition(relMeta, foreignKey);
+        }
         // Denormalize entity being updated to foreign partition
         this.buildLinkToForeignEntityTransaction(updatedEntity, relMeta, foreignKey);
         if ((0, utils_3.isBelongsToRelationship)(relMeta)) {
@@ -426,15 +439,17 @@ class Update extends OperationBase_1.default {
      * @param newForeignKey
      * @param oldForeignKey
      * @param newBelongsToEntityLookup
+     * @param referentialIntegrityCheck - Whether to perform referential integrity checks.
+     * @private
      */
-    updateForeignKeyTransactions(updatedEntity, relMeta, newForeignKey, oldForeignKey, newBelongsToEntityLookup) {
+    updateForeignKeyTransactions(updatedEntity, relMeta, newForeignKey, oldForeignKey, newBelongsToEntityLookup, referentialIntegrityCheck) {
         // 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");
+        this.buildPutBelongsToLinkedRecords(updatedEntity, relMeta, newForeignKey, newBelongsToEntityLookup, "attribute_exists", undefined, referentialIntegrityCheck);
     }
     /**
      * Builds transactions to update all related entities that exist in the main entity's partition, applying the same attribute updates.

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

@@ -28,6 +28,18 @@ type AllowNullForNullable<T> = {
  * })
  */
 export type UpdateOptions<T extends DynaRecord> = Partial<AllowNullForNullable<EntityDefinedAttributes<T>>>;
+/**
+ * Options for update operations
+ */
+export interface UpdateOperationOptions {
+    /**
+     * Whether to perform referential integrity checks for foreign key references.
+     * When `true` (default), condition checks are added to verify that referenced entities exist.
+     * When `false`, these condition checks are skipped, allowing updates even if foreign key references don't exist.
+     * @default true
+     */
+    referentialIntegrityCheck?: boolean;
+}
 /**
  * Attributes of an entity that were updated. Including the auto generated updatedAt date
  */

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/operations/Update/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAExD;;;;;GAKG;AACH,KAAK,kBAAkB,CAAC,CAAC,IAAI;KAC1B,CAAC,IAAI,MAAM,CAAC,GAAG,SAAS,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK;CACnD,CAAC,MAAM,CAAC,CAAC,CAAC;AAEX;;;;;GAKG;AACH,KAAK,oBAAoB,CAAC,CAAC,IAAI;KAC5B,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,SAAS,kBAAkB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC;CACrE,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,UAAU,IAAI,OAAO,CACvD,oBAAoB,CAAC,uBAAuB,CAAC,CAAC,CAAC,CAAC,CACjD,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,UAAU,IAAI,IAAI,CACxD,OAAO,CAAC,CAAC,CAAC,EACV,WAAW,CACZ,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/operations/Update/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAExD;;;;;GAKG;AACH,KAAK,kBAAkB,CAAC,CAAC,IAAI;KAC1B,CAAC,IAAI,MAAM,CAAC,GAAG,SAAS,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK;CACnD,CAAC,MAAM,CAAC,CAAC,CAAC;AAEX;;;;;GAKG;AACH,KAAK,oBAAoB,CAAC,CAAC,IAAI;KAC5B,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,SAAS,kBAAkB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC;CACrE,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,UAAU,IAAI,OAAO,CACvD,oBAAoB,CAAC,uBAAuB,CAAC,CAAC,CAAC,CAAC,CACjD,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;;;OAKG;IACH,yBAAyB,CAAC,EAAE,OAAO,CAAC;CACrC;AAED;;GAEG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,UAAU,IAAI,IAAI,CACxD,OAAO,CAAC,CAAC,CAAC,EACV,WAAW,CACZ,CAAC"}

package/dist/src/relationships/JoinTable.d.ts

@@ -10,6 +10,18 @@ type ExcludeKeys = "type1" | "type2";
 type ForeignKeyProperties<T> = {
     [P in Exclude<keyof T, ExcludeKeys>]: T[P] extends ForeignKey ? string : never;
 };
+/**
+ * Options for JoinTable operations
+ */
+interface JoinTableOptions {
+    /**
+     * Whether to perform referential integrity checks for foreign key references.
+     * When `true` (default), condition checks are added to verify that referenced entities exist.
+     * When `false`, these condition checks are skipped, allowing updates even if foreign key references don't exist.
+     * @default true
+     */
+    referentialIntegrityCheck?: boolean;
+}
 /**
  * Abstract class representing a join table for HasAndBelongsToMany relationships.
  * This class should be extended for specific join table implementations.
@@ -33,8 +45,9 @@ declare abstract class JoinTable<T extends DynaRecord, K extends DynaRecord> {
      * Adds denormalized copy of the related entity to each associated Entity's partition
      * @param this
      * @param keys
+     * @param options - Optional operation options including referentialIntegrityCheck flag
      */
-    static create<ThisClass extends JoinTable<T, K>, T extends DynaRecord, K extends DynaRecord>(this: new (type1: EntityClass<T>, type2: EntityClass<K>) => ThisClass, keys: ForeignKeyProperties<ThisClass>): Promise<void>;
+    static create<ThisClass extends JoinTable<T, K>, T extends DynaRecord, K extends DynaRecord>(this: new (type1: EntityClass<T>, type2: EntityClass<K>) => ThisClass, keys: ForeignKeyProperties<ThisClass>, options?: JoinTableOptions): Promise<void>;
     /**
      * Delete a JoinTable entry
      * Deletes denormalized records from each associated Entity's partition
@@ -51,6 +64,9 @@ declare abstract class JoinTable<T extends DynaRecord, K extends DynaRecord> {
      * @param keys
      * @param parentEntityMeta
      * @param linkedEntityMeta
+     * @param linkedRecord
+     * @param referentialIntegrityCheck - Whether to perform referential integrity checks.
+     * @private
      */
     private static denormalizeLinkRecord;
     /**

package/dist/src/relationships/JoinTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"JoinTable.d.ts","sourceRoot":"","sources":["../../../src/relationships/JoinTable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,eAAe,CAAC;AAW5C,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAmB,MAAM,UAAU,CAAC;AAEzE;;GAEG;AACH,KAAK,WAAW,GAAG,OAAO,GAAG,OAAO,CAAC;AAOrC;;GAEG;AACH,KAAK,oBAAoB,CAAC,CAAC,IAAI;KAC5B,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,UAAU,GACzD,MAAM,GACN,KAAK;CACV,CAAC;AAqBF;;;;;;;;;;;;;GAaG;AACH,uBAAe,SAAS,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,UAAU;IAE/D,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK;gBADL,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,EACrB,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC;IAGxC;;;;;OAKG;WACiB,MAAM,CACxB,SAAS,SAAS,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EACjC,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,UAAU,EAEpB,IAAI,EAAE,KAAK,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,SAAS,EACrE,IAAI,EAAE,oBAAoB,CAAC,SAAS,CAAC,GACpC,OAAO,CAAC,IAAI,CAAC;IAyBhB;;;;;OAKG;WACiB,MAAM,CACxB,SAAS,SAAS,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EACjC,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,UAAU,EAEpB,IAAI,EAAE,KAAK,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,SAAS,EACrE,IAAI,EAAE,oBAAoB,CAAC,SAAS,CAAC,GACpC,OAAO,CAAC,IAAI,CAAC;mBAWK,QAAQ;IAmD7B;;;;;;;;OAQG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IA2CpC;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAcpC;;;;;;;OAOG;IACH,OAAO,CAAC,MAAM,CAAC,UAAU;IA0BzB,OAAO,CAAC,MAAM,CAAC,YAAY;IAoB3B,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAoB/B,OAAO,CAAC,MAAM,CAAC,4BAA4B;CA6B5C;AAED,eAAe,SAAS,CAAC"}
+{"version":3,"file":"JoinTable.d.ts","sourceRoot":"","sources":["../../../src/relationships/JoinTable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,eAAe,CAAC;AAW5C,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAmB,MAAM,UAAU,CAAC;AAEzE;;GAEG;AACH,KAAK,WAAW,GAAG,OAAO,GAAG,OAAO,CAAC;AAOrC;;GAEG;AACH,KAAK,oBAAoB,CAAC,CAAC,IAAI;KAC5B,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,UAAU,GACzD,MAAM,GACN,KAAK;CACV,CAAC;AAYF;;GAEG;AACH,UAAU,gBAAgB;IACxB;;;;;OAKG;IACH,yBAAyB,CAAC,EAAE,OAAO,CAAC;CACrC;AAWD;;;;;;;;;;;;;GAaG;AACH,uBAAe,SAAS,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,UAAU;IAE/D,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK;gBADL,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,EACrB,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC;IAGxC;;;;;;OAMG;WACiB,MAAM,CACxB,SAAS,SAAS,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EACjC,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,UAAU,EAEpB,IAAI,EAAE,KAAK,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,SAAS,EACrE,IAAI,EAAE,oBAAoB,CAAC,SAAS,CAAC,EACrC,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,IAAI,CAAC;IA6BhB;;;;;OAKG;WACiB,MAAM,CACxB,SAAS,SAAS,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EACjC,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,UAAU,EAEpB,IAAI,EAAE,KAAK,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,SAAS,EACrE,IAAI,EAAE,oBAAoB,CAAC,SAAS,CAAC,GACpC,OAAO,CAAC,IAAI,CAAC;mBAWK,QAAQ;IAmD7B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IA8CpC;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAcpC;;;;;;;OAOG;IACH,OAAO,CAAC,MAAM,CAAC,UAAU;IA0BzB,OAAO,CAAC,MAAM,CAAC,YAAY;IAoB3B,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAoB/B,OAAO,CAAC,MAAM,CAAC,4BAA4B;CA6B5C;AAED,eAAe,SAAS,CAAC"}

package/dist/src/relationships/JoinTable.js

@@ -33,14 +33,16 @@ class JoinTable {
      * Adds denormalized copy of the related entity to each associated Entity's partition
      * @param this
      * @param keys
+     * @param options - Optional operation options including referentialIntegrityCheck flag
      */
-    static async create(keys) {
+    static async create(keys, options) {
+        const referentialIntegrityCheck = options?.referentialIntegrityCheck ?? true;
         const transactionBuilder = new TransactWriteBuilder_1.default();
         const [rel1, rel2] = metadata_1.default.getJoinTable(this.name);
         const transactionProps = JoinTable.transactionProps(keys, rel2, rel1);
         const lookupTableItem = await JoinTable.preFetch(transactionProps);
-        JoinTable.denormalizeLinkRecord(transactionBuilder, keys, rel1, rel2, lookupTableItem[transactionProps.ids.linkedEntityId]);
-        JoinTable.denormalizeLinkRecord(transactionBuilder, keys, rel2, rel1, lookupTableItem[transactionProps.ids.parentId]);
+        JoinTable.denormalizeLinkRecord(transactionBuilder, keys, rel1, rel2, lookupTableItem[transactionProps.ids.linkedEntityId], referentialIntegrityCheck);
+        JoinTable.denormalizeLinkRecord(transactionBuilder, keys, rel2, rel1, lookupTableItem[transactionProps.ids.parentId], referentialIntegrityCheck);
         await transactionBuilder.executeTransaction();
     }
     /**
@@ -90,8 +92,11 @@ class JoinTable {
      * @param keys
      * @param parentEntityMeta
      * @param linkedEntityMeta
+     * @param linkedRecord
+     * @param referentialIntegrityCheck - Whether to perform referential integrity checks.
+     * @private
      */
-    static denormalizeLinkRecord(transactionBuilder, keys, parentEntityMeta, linkedEntityMeta, linkedRecord) {
+    static denormalizeLinkRecord(transactionBuilder, keys, parentEntityMeta, linkedEntityMeta, linkedRecord, referentialIntegrityCheck) {
         const { tableProps, entities, ids } = this.transactionProps(keys, parentEntityMeta, linkedEntityMeta);
         const { name: tableName } = tableProps;
         const { alias: partitionKeyAlias } = tableProps.partitionKeyAttribute;
@@ -105,11 +110,13 @@ class JoinTable {
             },
             ConditionExpression: `attribute_not_exists(${partitionKeyAlias})` // Ensure item doesn't already exist
         }, `${parentEntity.name} with ID ${linkedEntityId} is already linked to ${linkedEntity.name} with ID ${parentId}`);
-        transactionBuilder.addConditionCheck({
-            TableName: tableName,
-            Key: this.buildForeignEntityKey(tableProps, parentEntity, linkedEntityId),
-            ConditionExpression: `attribute_exists(${partitionKeyAlias})`
-        }, `${parentEntity.name} with ID ${linkedEntityId} does not exist`);
+        if (referentialIntegrityCheck) {
+            transactionBuilder.addConditionCheck({
+                TableName: tableName,
+                Key: this.buildForeignEntityKey(tableProps, parentEntity, linkedEntityId),
+                ConditionExpression: `attribute_exists(${partitionKeyAlias})`
+            }, `${parentEntity.name} with ID ${linkedEntityId} does not exist`);
+        }
     }
     /**
      * Builds the key to the foreign entity

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dyna-record",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Typescript Data Modeler and ORM for Dynamo",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",