dyna-record 0.0.1

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

@@ -0,0 +1,48 @@
+import type DynaRecord from "../../DynaRecord";
+import OperationBase from "../OperationBase";
+import type { UpdateOptions } from "./types";
+import type { EntityClass } from "../../types";
+/**
+ * Facilitates the operation of updating an existing entity in the database, including handling updates to its attributes and managing changes to its relationships. It will de-normalize data to support relationship links
+ *
+ * The `Update` operation supports updating entity attributes and ensures consistency in relationships, especially for "BelongsTo" relationships. It handles the complexity of managing foreign keys and associated "BelongsToLink" records, including creating new links for updated relationships and removing outdated links when necessary.
+ *
+ * @template T - The type of the entity being updated, extending `DynaRecord`.
+ */
+declare class Update<T extends DynaRecord> extends OperationBase<T> {
+    #private;
+    constructor(Entity: EntityClass<T>);
+    /**
+     * Update entity transactions, including transactions to create/update BelongsToLinks
+     * @param id The id of the entity being updated
+     * @param attributes Attributes on the model to update.
+     */
+    run(id: string, attributes: UpdateOptions<T>): Promise<void>;
+    /**
+     * Build the transaction to update the entity
+     * @param id The id of the entity being updated
+     * @param attributes Attributes on the model to update.
+     */
+    private buildUpdateItemTransaction;
+    /**
+     * Builds the transactions to persist relationships
+     *   - Creates BelongsToLinks when a foreign key changes
+     *   - Removes outdated BelongsToLinks if the entity previously was associated with a different entity
+     * @param id The id of the entity being updated
+     * @param attributes Attributes on the model to update.
+     */
+    private buildRelationshipTransactions;
+    /**
+     * When updating the foreign key of an entity, delete the BelongsToLink in the previous relationships partition
+     * @param rel
+     * @param relType
+     * @param entity
+     */
+    private buildDeleteOldBelongsToLinkTransaction;
+    /**
+     * If updating a ForeignKey, look up the current state of the item to build transactions
+     */
+    private getEntity;
+}
+export default Update;
+//# sourceMappingURL=Update.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Update.d.ts","sourceRoot":"","sources":["../../../../src/operations/Update/Update.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAa/C,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;;GAMG;AACH,cAAM,MAAM,CAAC,CAAC,SAAS,UAAU,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC;;gBAK7C,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;IAKlC;;;;OAIG;IACU,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAMzE;;;;OAIG;IACH,OAAO,CAAC,0BAA0B;IAkClC;;;;;;OAMG;YACW,6BAA6B;IAsB3C;;;;;OAKG;IACH,OAAO,CAAC,sCAAsC;IAyB9C;;OAEG;YACW,SAAS;CAOxB;AAED,eAAe,MAAM,CAAC"}

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

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dynamo_utils_1 = require("../../dynamo-utils");
+const utils_1 = require("../../utils");
+const utils_2 = require("../utils");
+const OperationBase_1 = __importDefault(require("../OperationBase"));
+/**
+ * Facilitates the operation of updating an existing entity in the database, including handling updates to its attributes and managing changes to its relationships. It will de-normalize data to support relationship links
+ *
+ * The `Update` operation supports updating entity attributes and ensures consistency in relationships, especially for "BelongsTo" relationships. It handles the complexity of managing foreign keys and associated "BelongsToLink" records, including creating new links for updated relationships and removing outdated links when necessary.
+ *
+ * @template T - The type of the entity being updated, extending `DynaRecord`.
+ */
+class Update extends OperationBase_1.default {
+    #transactionBuilder;
+    #entity;
+    constructor(Entity) {
+        super(Entity);
+        this.#transactionBuilder = new dynamo_utils_1.TransactWriteBuilder();
+    }
+    /**
+     * Update entity transactions, including transactions to create/update BelongsToLinks
+     * @param id The id of the entity being updated
+     * @param attributes Attributes on the model to update.
+     */
+    async run(id, attributes) {
+        this.buildUpdateItemTransaction(id, attributes);
+        await this.buildRelationshipTransactions(id, attributes);
+        await this.#transactionBuilder.executeTransaction();
+    }
+    /**
+     * Build the transaction to update the entity
+     * @param id The id of the entity being updated
+     * @param attributes Attributes on the model to update.
+     */
+    buildUpdateItemTransaction(id, attributes) {
+        const { name: tableName } = this.tableMetadata;
+        const pk = this.tableMetadata.partitionKeyAttribute.name;
+        const sk = this.tableMetadata.sortKeyAttribute.name;
+        const keys = {
+            [pk]: this.EntityClass.partitionKeyValue(id),
+            [sk]: this.EntityClass.name
+        };
+        const updatedAttrs = {
+            ...attributes,
+            updatedAt: new Date()
+        };
+        const tableKeys = (0, utils_1.entityToTableItem)(this.EntityClass, keys);
+        const tableAttrs = (0, utils_1.entityToTableItem)(this.EntityClass, updatedAttrs);
+        const expression = (0, utils_2.expressionBuilder)(tableAttrs);
+        this.#transactionBuilder.addUpdate({
+            TableName: tableName,
+            Key: tableKeys,
+            ConditionExpression: `attribute_exists(${this.partitionKeyAlias})`, // Only update the item if it exists
+            ...expression
+        }, `${this.EntityClass.name} with ID '${id}' does not exist`);
+    }
+    /**
+     * Builds the transactions to persist relationships
+     *   - Creates BelongsToLinks when a foreign key changes
+     *   - Removes outdated BelongsToLinks if the entity previously was associated with a different entity
+     * @param id The id of the entity being updated
+     * @param attributes Attributes on the model to update.
+     */
+    async buildRelationshipTransactions(id, attributes) {
+        const entityData = { id, ...attributes };
+        const relationshipTransactions = new utils_2.RelationshipTransactions({
+            Entity: this.EntityClass,
+            transactionBuilder: this.#transactionBuilder,
+            belongsToHasManyCb: async (rel, entityId) => {
+                const entity = await this.getEntity(entityId);
+                this.buildDeleteOldBelongsToLinkTransaction(rel, "HasMany", entity);
+            },
+            belongsToHasOneCb: async (rel, entityId) => {
+                const entity = await this.getEntity(entityId);
+                this.buildDeleteOldBelongsToLinkTransaction(rel, "HasOne", entity);
+            }
+        });
+        await relationshipTransactions.build(entityData);
+    }
+    /**
+     * When updating the foreign key of an entity, delete the BelongsToLink in the previous relationships partition
+     * @param rel
+     * @param relType
+     * @param entity
+     */
+    buildDeleteOldBelongsToLinkTransaction(rel, relType, entity) {
+        const { name: tableName } = this.tableMetadata;
+        const currentId = (0, utils_2.extractForeignKeyFromEntity)(rel, entity);
+        if (entity !== undefined && currentId !== undefined) {
+            const oldLinkKeys = {
+                [this.partitionKeyAlias]: rel.target.partitionKeyValue(currentId),
+                [this.sortKeyAlias]: relType === "HasMany"
+                    ? this.EntityClass.partitionKeyValue(entity.id)
+                    : this.EntityClass.name
+            };
+            this.#transactionBuilder.addDelete({
+                TableName: tableName,
+                Key: oldLinkKeys
+            });
+        }
+    }
+    /**
+     * If updating a ForeignKey, look up the current state of the item to build transactions
+     */
+    async getEntity(id) {
+        // Only get the item once per transaction
+        if (this.#entity !== undefined)
+            return this.#entity;
+        const res = (await this.EntityClass.findById(id));
+        this.#entity = res ?? undefined;
+        return this.#entity;
+    }
+}
+exports.default = Update;

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

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

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

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

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

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Update = void 0;
+var Update_1 = require("./Update");
+Object.defineProperty(exports, "Update", { enumerable: true, get: function () { return __importDefault(Update_1).default; } });
+__exportStar(require("./types"), exports);

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

@@ -0,0 +1,32 @@
+import type DynaRecord from "../../DynaRecord";
+import type { EntityDefinedAttributes } from "../types";
+/**
+ * Extracts the keys of properties in type `T` that are explicitly allowed to be `undefined`.
+ *
+ * @typeParam T - The type whose properties are to be examined.
+ * @returns A union type of the keys of `T` that can be `undefined`.
+ */
+type NullableProperties<T> = {
+    [K in keyof T]: undefined extends T[K] ? K : never;
+}[keyof T];
+/**
+ * Transforms a type `T` by allowing `null` as an additional type for its nullable properties.
+ *
+ * @typeParam T - The type whose properties are to be transformed.
+ * @returns A new type with properties of `T` where each nullable property is also allowed to be `null`.
+ */
+type AllowNullForNullable<T> = {
+    [K in keyof T]: K extends NullableProperties<T> ? T[K] | null : T[K];
+};
+/**
+ * Attributes of an entity to update. Not all properties are required. Setting a nullable property to null will remove the attribute from the item
+ *
+ * @example
+ * await MockModel.update("123", {
+ *   nonNullableAttr: "new val", // Sets new value
+ *   nullableAttr: null // Remove the value. This will throw a compile time error if the property is not nullable
+ * })
+ */
+export type UpdateOptions<T extends DynaRecord> = Partial<AllowNullForNullable<EntityDefinedAttributes<T>>>;
+export {};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,7 @@
+export * from "./FindById";
+export * from "./Query";
+export * from "./Update";
+export * from "./Create";
+export * from "./Delete";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/operations/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC"}

package/dist/src/operations/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./FindById"), exports);
+__exportStar(require("./Query"), exports);
+__exportStar(require("./Update"), exports);
+__exportStar(require("./Create"), exports);
+__exportStar(require("./Delete"), exports);
+__exportStar(require("./types"), exports);

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

@@ -0,0 +1,59 @@
+import type DynaRecord from "../DynaRecord";
+import type { ForeignKey, NullableForeignKey, Optional, PartitionKey, SortKey } from "../types";
+/**
+ * Represents the type of the partition key attribute for a given entity. It identifies the specific property of the entity that is marked as the partition key, which uniquely identifies each instance of the entity in the database.
+ *
+ * @template T - The type of the entity being examined.
+ * @returns The name of the partition key attribute as a string if one exists; otherwise, the result is `never`.
+ */
+export type PartitionKeyAttribute<T> = {
+    [K in keyof T]: T[K] extends PartitionKey ? K : never;
+}[keyof T];
+/**
+ * Represents the type of the sort key attribute for a given entity. It identifies the specific property of the entity that is marked as the sort key, used in conjunction with the partition key to provide additional sorting capability within the database.
+ *
+ * @template T - The type of the entity being examined.
+ * @returns The name of the sort key attribute as a string if one exists; otherwise, the result is `never`.
+ */
+export type SortKeyAttribute<T> = {
+    [K in keyof T]: T[K] extends SortKey ? K : never;
+}[keyof T];
+/**
+ * Identifies all properties of a given entity type `T` that are functions. This type is useful for filtering out or working with only the function fields of an entity.
+ *
+ * @template T - The type of the entity being examined.
+ * @returns The names of the function properties as strings if any exist; otherwise, the result is `never`.
+ */
+export type FunctionFields<T> = {
+    [K in keyof T]: T[K] extends Function ? K : never;
+}[keyof T];
+/**
+ * Allow ForeignKey attributes to be passes to the create method by using their inferred primitive type
+ * Ex:
+ *  If ModelA has: attr1: ForeignKey
+ *  This allows" ModelA.create({ attr1: "someVal" })
+ *  Instead of: ModelA.create({ attr1: "someVal" as ForeignKey })
+ */
+export type ForeignKeyToValue<T> = {
+    [K in keyof T]: T[K] extends NullableForeignKey ? Optional<string> : T[K] extends ForeignKey ? string : T[K];
+};
+/**
+ * Returns Keys of T which are HasMany, BelongsTo or HasOne relationships
+ */
+export type RelationshipAttributeNames<T> = {
+    [K in keyof T]: Exclude<T[K], undefined> extends DynaRecord | DynaRecord[] ? K : never;
+}[keyof T];
+/**
+ * Entity attributes excluding relationship attributes
+ */
+export type EntityAttributes<T extends DynaRecord> = Omit<T, RelationshipAttributeNames<T>>;
+/**
+ * Attributes that are defined on the Entity using the @Attribute decorators. This excludes:
+ *   - relationship attributes
+ *   - partition key attribute
+ *   - sort key attribute
+ *   - dyna-record default attributes
+ *   - Functions defined on the entity
+ */
+export type EntityDefinedAttributes<T extends DynaRecord> = Omit<ForeignKeyToValue<T>, keyof DynaRecord | RelationshipAttributeNames<T> | FunctionFields<T> | PartitionKeyAttribute<T> | SortKeyAttribute<T>>;
+//# sourceMappingURL=types.d.ts.map

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

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

package/dist/src/operations/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,64 @@
+import type DynaRecord from "../../DynaRecord";
+import type { TransactWriteBuilder } from "../../dynamo-utils";
+import { type BelongsToRelationship } from "../../metadata";
+import type { EntityClass } from "../../types";
+type EntityData<T extends DynaRecord> = Pick<T, "id"> & Partial<T>;
+interface RelationshipTransactionsProps<T extends DynaRecord> {
+    /**
+     * Entity for which relationships are being persisted
+     */
+    readonly Entity: EntityClass<T>;
+    /**
+     * TransactionBuilder instance to add relationship transactions to
+     */
+    readonly transactionBuilder: TransactWriteBuilder;
+    /**
+     * Optional callback to add logic to persisting BelongsTo HasMany relationships
+     * @param rel The BelongsToRelationship metadata of which the Entity BelongsTo HasMany of
+     * @param entityId The ID of the entity
+     * @returns
+     */
+    belongsToHasManyCb?: (rel: BelongsToRelationship, entityId: string) => Promise<void>;
+    /**
+     * Optional callback to add logic to persisting BelongsTo HasOne relationships
+     * @param rel The BelongsToRelationship metadata of which the Entity BelongsTo HasOne of
+     * @param entityId The ID of the entity
+     * @returns
+     */
+    belongsToHasOneCb?: (rel: BelongsToRelationship, entityId: string) => Promise<void>;
+}
+/**
+ * Builds transactions for persisting create/update relationships
+ *   - Sets/removes ForeignKeys
+ *   - Adds/removes BelongsToLinks
+ */
+declare class RelationshipTransactions<T extends DynaRecord> {
+    #private;
+    constructor(props: RelationshipTransactionsProps<T>);
+    build<T extends DynaRecord>(entityData: EntityData<T>): Promise<void>;
+    /**
+     * Builds a ConditionCheck transaction that ensures the associated relationship exists
+     * @param rel
+     * @param relationshipId
+     * @returns
+     */
+    private buildRelationshipExistsConditionTransaction;
+    /**
+     * Creates a BelongsToLink transaction item in the parents partition if the entity BelongsTo a HasOne association
+     * Adds conditional check to ensure the parent doesn't already have one of the entity being associated
+     * @param entityId Id of the entity being persisted
+     * @param rel BelongsTo relationship metadata for which the entity being persisted is a BelongsTo HasOne
+     * @param relationshipId Id of the parent entity of which the entity being persisted BelongsTo
+     */
+    private buildBelongsToHasOne;
+    /**
+     * Creates a BelongsToLink transaction item in the parents partition if the entity BelongsTo a HasMany association
+     * @param rel BelongsTo relationship metadata for which the entity being persisted is a BelongsTo HasMany
+     * @param entityId Id of the entity being persisted
+     * @param relationshipId Id of the parent entity of which the entity being persisted BelongsTo
+     */
+    private buildBelongsToHasMany;
+    private isNullableString;
+}
+export default RelationshipTransactions;
+//# sourceMappingURL=RelationshipTransactions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RelationshipTransactions.d.ts","sourceRoot":"","sources":["../../../../src/operations/utils/RelationshipTransactions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAGV,oBAAoB,EACrB,MAAM,oBAAoB,CAAC;AAC5B,OAAiB,EAEf,KAAK,qBAAqB,EAE3B,MAAM,gBAAgB,CAAC;AAOxB,OAAO,KAAK,EAAE,WAAW,EAAY,MAAM,aAAa,CAAC;AAIzD,KAAK,UAAU,CAAC,CAAC,SAAS,UAAU,IAAI,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAEnE,UAAU,6BAA6B,CAAC,CAAC,SAAS,UAAU;IAC1D;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IAChC;;OAEG;IACH,QAAQ,CAAC,kBAAkB,EAAE,oBAAoB,CAAC;IAClD;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,CACnB,GAAG,EAAE,qBAAqB,EAC1B,QAAQ,EAAE,MAAM,KACb,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,CAClB,GAAG,EAAE,qBAAqB,EAC1B,QAAQ,EAAE,MAAM,KACb,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB;AAED;;;;GAIG;AACH,cAAM,wBAAwB,CAAC,CAAC,SAAS,UAAU;;gBAOrC,KAAK,EAAE,6BAA6B,CAAC,CAAC,CAAC;IAUtC,KAAK,CAAC,CAAC,SAAS,UAAU,EACrC,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GACxB,OAAO,CAAC,IAAI,CAAC;IAoChB;;;;;OAKG;IACH,OAAO,CAAC,2CAA2C;IAoBnD;;;;;;OAMG;YACW,oBAAoB;IAgClC;;;;;OAKG;YACW,qBAAqB;IAkCnC,OAAO,CAAC,gBAAgB;CAGzB;AAED,eAAe,wBAAwB,CAAC"}

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

@@ -0,0 +1,125 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const metadata_1 = __importDefault(require("../../metadata"));
+const utils_1 = require("../../metadata/utils");
+const relationships_1 = require("../../relationships");
+const utils_2 = require("../../utils");
+const utils_3 = require("./utils");
+/**
+ * Builds transactions for persisting create/update relationships
+ *   - Sets/removes ForeignKeys
+ *   - Adds/removes BelongsToLinks
+ */
+class RelationshipTransactions {
+    #props;
+    #entityMetadata;
+    #tableMetadata;
+    #partitionKeyAlias;
+    #sortKeyAlias;
+    constructor(props) {
+        this.#props = props;
+        this.#entityMetadata = metadata_1.default.getEntity(props.Entity.name);
+        this.#tableMetadata = metadata_1.default.getTable(this.#entityMetadata.tableClassName);
+        this.#partitionKeyAlias = this.#tableMetadata.partitionKeyAttribute.alias;
+        this.#sortKeyAlias = this.#tableMetadata.sortKeyAttribute.alias;
+    }
+    async build(entityData) {
+        const { relationships } = this.#entityMetadata;
+        for (const rel of Object.values(relationships)) {
+            const isBelongsTo = (0, utils_1.isBelongsToRelationship)(rel);
+            if (isBelongsTo) {
+                const relationshipId = (0, utils_3.extractForeignKeyFromEntity)(rel, entityData);
+                const isUpdatingRelationshipId = relationshipId !== undefined;
+                if (isUpdatingRelationshipId && this.isNullableString(relationshipId)) {
+                    if (relationshipId !== null) {
+                        this.buildRelationshipExistsConditionTransaction(rel, relationshipId);
+                    }
+                    const callbackParams = [rel, entityData.id, relationshipId];
+                    if ((0, utils_1.doesEntityBelongToRelAsHasMany)(this.#props.Entity, rel)) {
+                        await this.buildBelongsToHasMany(...callbackParams);
+                    }
+                    if ((0, utils_1.doesEntityBelongToRelAsHasOne)(this.#props.Entity, rel)) {
+                        await this.buildBelongsToHasOne(...callbackParams);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Builds a ConditionCheck transaction that ensures the associated relationship exists
+     * @param rel
+     * @param relationshipId
+     * @returns
+     */
+    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.#props.transactionBuilder.addConditionCheck(conditionCheck, errMsg);
+    }
+    /**
+     * Creates a BelongsToLink transaction item in the parents partition if the entity BelongsTo a HasOne association
+     * Adds conditional check to ensure the parent doesn't already have one of the entity being associated
+     * @param entityId Id of the entity being persisted
+     * @param rel BelongsTo relationship metadata for which the entity being persisted is a BelongsTo HasOne
+     * @param relationshipId Id of the parent entity of which the entity being persisted BelongsTo
+     */
+    async buildBelongsToHasOne(rel, entityId, relationshipId) {
+        const { name: tableName } = this.#tableMetadata;
+        if (this.#props.belongsToHasOneCb !== undefined) {
+            await this.#props.belongsToHasOneCb(rel, entityId);
+        }
+        if (relationshipId !== null) {
+            const link = relationships_1.BelongsToLink.build(this.#props.Entity.name, entityId);
+            const keys = {
+                [this.#partitionKeyAlias]: rel.target.partitionKeyValue(relationshipId),
+                [this.#sortKeyAlias]: this.#props.Entity.name
+            };
+            const putExpression = {
+                TableName: tableName,
+                Item: { ...keys, ...(0, utils_2.entityToTableItem)(rel.target, link) },
+                ConditionExpression: `attribute_not_exists(${this.#partitionKeyAlias})` // Ensure item doesn't already exist
+            };
+            this.#props.transactionBuilder.addPut(putExpression, `${rel.target.name} with id: ${relationshipId} already has an associated ${this.#props.Entity.name}`);
+        }
+    }
+    /**
+     * Creates a BelongsToLink transaction item in the parents partition if the entity BelongsTo a HasMany association
+     * @param rel BelongsTo relationship metadata for which the entity being persisted is a BelongsTo HasMany
+     * @param entityId Id of the entity being persisted
+     * @param relationshipId Id of the parent entity of which the entity being persisted BelongsTo
+     */
+    async buildBelongsToHasMany(rel, entityId, relationshipId) {
+        const { name: tableName } = this.#tableMetadata;
+        if (this.#props.belongsToHasManyCb !== undefined) {
+            await this.#props.belongsToHasManyCb(rel, entityId);
+        }
+        if (relationshipId !== null) {
+            const link = relationships_1.BelongsToLink.build(this.#props.Entity.name, entityId);
+            const keys = {
+                [this.#partitionKeyAlias]: rel.target.partitionKeyValue(relationshipId),
+                [this.#sortKeyAlias]: this.#props.Entity.partitionKeyValue(link.foreignKey)
+            };
+            const putExpression = {
+                TableName: tableName,
+                Item: { ...keys, ...(0, utils_2.entityToTableItem)(rel.target, link) },
+                ConditionExpression: `attribute_not_exists(${this.#partitionKeyAlias})` // Ensure item doesn't already exist
+            };
+            this.#props.transactionBuilder.addPut(putExpression, `${this.#props.Entity.name} with ID '${entityId}' already belongs to ${rel.target.name} with Id '${relationshipId}'`);
+        }
+    }
+    isNullableString(val) {
+        return typeof val === "string" || val === null;
+    }
+}
+exports.default = RelationshipTransactions;

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

@@ -0,0 +1,9 @@
+import type { DynamoTableItem } from "../../types";
+import type { UpdateExpression } from "./types";
+/**
+ * Builds a dynamo expression given the table attributes
+ * @param tableAttrs The table aliases of the entity attributes
+ * @returns
+ */
+export declare const expressionBuilder: (tableAttrs: DynamoTableItem) => UpdateExpression;
+//# sourceMappingURL=expressionBuilder.d.ts.map

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

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