dyna-record 0.1.5 → 0.2.0

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

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

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/operations/Delete/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,MAAM,WAAW,aAAa;IAC5B,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,UAAU,IAAI,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/operations/Delete/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC5B,YAAY,EAAE,MAAM,CAAC;CACtB"}

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

@@ -36,33 +36,12 @@ declare class FindById<T extends DynaRecord> extends OperationBase<T> {
      */
     private findByIdWithIncludes;
     /**
-     * Build the query to find the entity, and any of the BelongsToLinks for the included models
-     * @param id
-     * @param includedRelationships
-     * @returns
-     */
-    private buildFindByIdIncludesQuery;
-    /**
-     * Sort query results into an object containing:
-     *  - item: The FindById DynamoItem
-     *  - belongsToLinks: BelongsToLinkDynamoItem records for each of the included relationships
-     * @param queryResults
+     * Filters query results by parent entity and related entities for processing
+     * @param entityId - The id of the parent entity
+     * @param queryResults - The results of the query on the parent partition
      * @returns
      */
     private filterQueryResults;
-    private buildGetIncludedRelationshipsTransaction;
-    /**
-     * Builds transactions to get an associated entity via a BelongsToLink (HasOne or HasMany)
-     * @param belongsToLinks
-     * @param relationsLookup
-     */
-    private buildGetRelationshipsThroughLinksTransaction;
-    /**
-     * Builds transactions to get an associated entity using a foreign key on the parent model (BelongsTo)
-     * @param belongsToLinks
-     * @param relationsLookup
-     */
-    private buildGetRelationshipsThroughForeignKeyTransaction;
     /**
      * Get relationship metadata for the associations included in the query
      * @param includedAssociations
@@ -70,10 +49,10 @@ declare class FindById<T extends DynaRecord> extends OperationBase<T> {
      */
     private getIncludedRelationships;
     /**
-     * Serialize the FindById item to its class, serialize results from included relationships query onto the entity
-     * @param entityTableItem
-     * @param transactionResults
-     * @param relationsLookup
+     * Resolve query results into parent entity with included relationships
+     * @param parentEntity
+     * @param relatedEntities
+     * @param includedRelMeta
      * @returns
      */
     private resolveFindByIdIncludesResults;

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

@@ -1 +1 @@
-{"version":3,"file":"FindById.d.ts","sourceRoot":"","sources":["../../../../src/operations/FindById/FindById.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAW/C,OAAO,KAAK,EAIV,WAAW,EACX,QAAQ,EACT,MAAM,aAAa,CAAC;AASrB,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EAGpB,MAAM,SAAS,CAAC;AAQjB;;;;;;GAMG;AACH,cAAM,QAAQ,CAAC,CAAC,SAAS,UAAU,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC;;gBAG/C,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;IAKlC;;;;;;;OAOG;IACU,GAAG,CACd,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,GAC3B,OAAO,CAAC,QAAQ,CAAC,CAAC,GAAG,mBAAmB,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAQpE;;;;OAIG;YACW,YAAY;IAmB1B;;;;;;OAMG;YACW,oBAAoB;IAiClC;;;;;OAKG;IACH,OAAO,CAAC,0BAA0B;IAkBlC;;;;;;OAMG;IACH,OAAO,CAAC,kBAAkB;IAa1B,OAAO,CAAC,wCAAwC;IAehD;;;;OAIG;IACH,OAAO,CAAC,4CAA4C;IA6BpD;;;;OAIG;IACH,OAAO,CAAC,iDAAiD;IA0BzD;;;;OAIG;IACH,OAAO,CAAC,wBAAwB;IAchC;;;;;;OAMG;IACH,OAAO,CAAC,8BAA8B;IAyCtC;;;;;;;OAOG;IACH,OAAO,CAAC,+BAA+B;CAexC;AAED,eAAe,QAAQ,CAAC"}
+{"version":3,"file":"FindById.d.ts","sourceRoot":"","sources":["../../../../src/operations/FindById/FindById.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAI/C,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAsB,MAAM,aAAa,CAAC;AAE7E,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EAGpB,MAAM,SAAS,CAAC;AAQjB;;;;;;GAMG;AACH,cAAM,QAAQ,CAAC,CAAC,SAAS,UAAU,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC;;gBAG/C,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;IAKlC;;;;;;;OAOG;IACU,GAAG,CACd,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,GAC3B,OAAO,CAAC,QAAQ,CAAC,CAAC,GAAG,mBAAmB,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAQpE;;;;OAIG;YACW,YAAY;IAmB1B;;;;;;OAMG;YACW,oBAAoB;IA4BlC;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB;IAkB1B;;;;OAIG;IACH,OAAO,CAAC,wBAAwB;IAchC;;;;;;OAMG;IACH,OAAO,CAAC,8BAA8B;IA0BtC;;;;;;;OAOG;IACH,OAAO,CAAC,+BAA+B;CAaxC;AAED,eAAe,QAAQ,CAAC"}

package/dist/src/operations/FindById/FindById.js

@@ -3,16 +3,12 @@ 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 dynamo_utils_1 = require("../../dynamo-utils");
-const query_utils_1 = require("../../query-utils");
 const Filters_1 = require("../../query-utils/Filters");
-const dynamo_utils_2 = require("../../dynamo-utils");
+const dynamo_utils_1 = require("../../dynamo-utils");
 const utils_1 = require("../../utils");
 const OperationBase_1 = __importDefault(require("../OperationBase"));
 const utils_2 = require("../utils");
 const utils_3 = require("../../metadata/utils");
-const Logger_1 = __importDefault(require("../../Logger"));
 /**
  * Facilitates the retrieval of an entity by its identifier (ID) from the database, potentially including its associated entities based on specified relationships.
  *
@@ -24,7 +20,7 @@ class FindById extends OperationBase_1.default {
     #transactionBuilder;
     constructor(Entity) {
         super(Entity);
-        this.#transactionBuilder = new dynamo_utils_2.TransactGetBuilder();
+        this.#transactionBuilder = new dynamo_utils_1.TransactGetBuilder();
     }
     /**
      * Find an entity by Id and optionally include associations
@@ -72,107 +68,34 @@ class FindById extends OperationBase_1.default {
      * @returns An entity with included associations serialized
      */
     async findByIdWithIncludes(id, includedAssociations) {
-        const includedRels = this.getIncludedRelationships(includedAssociations);
-        const params = this.buildFindByIdIncludesQuery(id, includedRels);
-        const queryResults = await dynamo_utils_1.DynamoClient.query({
-            ...params,
-            ConsistentRead: true
+        const includedRelMeta = this.getIncludedRelationships(includedAssociations);
+        const includedTypesFilter = (0, Filters_1.includedRelationshipsFilter)(this.EntityClass.name, includedRelMeta);
+        const queryResults = await this.EntityClass.query(id, {
+            filter: includedTypesFilter
         });
-        if (queryResults.length === 0) {
+        if (queryResults.length === 0)
             return undefined;
-        }
-        const sortedQueryResults = this.filterQueryResults(queryResults);
-        const relationsObj = (0, utils_2.buildEntityRelationshipMetaObj)(includedRels);
-        this.buildGetIncludedRelationshipsTransaction(sortedQueryResults, relationsObj);
-        const transactionRes = await this.#transactionBuilder.executeTransaction();
-        return this.resolveFindByIdIncludesResults(sortedQueryResults.item, transactionRes, relationsObj.relationsLookup);
+        const filtered = this.filterQueryResults(id, queryResults);
+        if (filtered.entity === undefined)
+            return;
+        return this.resolveFindByIdIncludesResults(filtered.entity, filtered.relatedEntities, includedRelMeta);
     }
     /**
-     * Build the query to find the entity, and any of the BelongsToLinks for the included models
-     * @param id
-     * @param includedRelationships
+     * Filters query results by parent entity and related entities for processing
+     * @param entityId - The id of the parent entity
+     * @param queryResults - The results of the query on the parent partition
      * @returns
      */
-    buildFindByIdIncludesQuery(id, includedRelationships) {
-        const modelPartitionKey = this.tableMetadata.partitionKeyAttribute.name;
-        const partitionFilter = (0, Filters_1.includedRelationshipsFilter)(this.EntityClass.name, includedRelationships);
-        return new query_utils_1.QueryBuilder({
-            entityClassName: this.EntityClass.name,
-            key: { [modelPartitionKey]: this.EntityClass.partitionKeyValue(id) },
-            options: { filter: partitionFilter }
-        }).build();
-    }
-    /**
-     * Sort query results into an object containing:
-     *  - item: The FindById DynamoItem
-     *  - belongsToLinks: BelongsToLinkDynamoItem records for each of the included relationships
-     * @param queryResults
-     * @returns
-     */
-    filterQueryResults(queryResults) {
+    filterQueryResults(entityId, queryResults) {
         return queryResults.reduce((acc, res) => {
-            const typeAlias = this.tableMetadata.defaultAttributes.type.alias;
-            if (res[typeAlias] === this.EntityClass.name)
-                acc.item = res;
-            if ((0, utils_1.isBelongsToLinkDynamoItem)(res, this.tableMetadata))
-                acc.belongsToLinks.push(res);
-            return acc;
-        }, { item: {}, belongsToLinks: [] });
-    }
-    buildGetIncludedRelationshipsTransaction(sortedQueryResults, relationsObj) {
-        this.buildGetRelationshipsThroughLinksTransaction(sortedQueryResults.belongsToLinks, relationsObj.relationsLookup);
-        this.buildGetRelationshipsThroughForeignKeyTransaction(sortedQueryResults.item, relationsObj.belongsToRelationships);
-    }
-    /**
-     * Builds transactions to get an associated entity via a BelongsToLink (HasOne or HasMany)
-     * @param belongsToLinks
-     * @param relationsLookup
-     */
-    buildGetRelationshipsThroughLinksTransaction(belongsToLinks, relationsLookup) {
-        const { name: tableName, defaultAttributes } = this.tableMetadata;
-        belongsToLinks.forEach(link => {
-            const foreignKey = link[defaultAttributes.foreignKey.alias];
-            const foreignEntityType = link[defaultAttributes.foreignEntityType.alias];
-            if ((0, utils_1.isPropertyKey)(foreignEntityType) && (0, utils_1.isString)(foreignKey)) {
-                const rel = relationsLookup[foreignEntityType];
-                this.#transactionBuilder.addGet({
-                    TableName: tableName,
-                    Key: {
-                        [this.partitionKeyAlias]: rel.target.partitionKeyValue(foreignKey),
-                        [this.sortKeyAlias]: rel.target.name
-                    }
-                });
+            if (entityId === res.id) {
+                acc.entity = res;
             }
             else {
-                Logger_1.default.error(
-                // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                `Corrupted foreign key value. Invalid type. ${foreignEntityType} - ${foreignKey}`);
+                acc.relatedEntities.push(res);
             }
-        });
-    }
-    /**
-     * Builds transactions to get an associated entity using a foreign key on the parent model (BelongsTo)
-     * @param belongsToLinks
-     * @param relationsLookup
-     */
-    buildGetRelationshipsThroughForeignKeyTransaction(item, belongsToRelationships) {
-        if (belongsToRelationships.length > 0) {
-            const { name: tableName } = this.tableMetadata;
-            const attributes = metadata_1.default.getEntityAttributes(this.EntityClass.name);
-            belongsToRelationships.forEach(rel => {
-                const foreignKeyTableAlias = attributes[rel.foreignKey].alias;
-                const foreignKeyVal = item[foreignKeyTableAlias];
-                if (foreignKeyVal === undefined)
-                    return;
-                this.#transactionBuilder.addGet({
-                    TableName: tableName,
-                    Key: {
-                        [this.partitionKeyAlias]: rel.target.partitionKeyValue(foreignKeyVal),
-                        [this.sortKeyAlias]: rel.target.name
-                    }
-                });
-            });
-        }
+            return acc;
+        }, { entity: undefined, relatedEntities: [] });
     }
     /**
      * Get relationship metadata for the associations included in the query
@@ -189,35 +112,25 @@ class FindById extends OperationBase_1.default {
         }, []);
     }
     /**
-     * Serialize the FindById item to its class, serialize results from included relationships query onto the entity
-     * @param entityTableItem
-     * @param transactionResults
-     * @param relationsLookup
+     * Resolve query results into parent entity with included relationships
+     * @param parentEntity
+     * @param relatedEntities
+     * @param includedRelMeta
      * @returns
      */
-    resolveFindByIdIncludesResults(entityTableItem, transactionResults, relationsLookup) {
-        const parentEntity = (0, utils_1.tableItemToEntity)(this.EntityClass, entityTableItem);
-        const typeAlias = this.tableMetadata.defaultAttributes.type.alias;
+    resolveFindByIdIncludesResults(parentEntity, relatedEntities, includedRelMeta) {
+        const { relationsLookup } = (0, utils_2.buildEntityRelationshipMetaObj)(includedRelMeta);
         this.setIncludedRelationshipDefaults(parentEntity, relationsLookup);
-        transactionResults.forEach(res => {
-            const tableItem = res.Item;
-            if (tableItem !== undefined) {
-                const rel = relationsLookup[tableItem[typeAlias]];
-                if ((0, utils_1.isKeyOfEntity)(parentEntity, rel.propertyName)) {
-                    if (rel.type === "HasMany" || rel.type === "HasAndBelongsToMany") {
-                        const entity = (0, utils_1.tableItemToEntity)(rel.target, tableItem);
-                        const entities = parentEntity[rel.propertyName] ?? [];
-                        if (Array.isArray(entities)) {
-                            entities.push(entity);
-                        }
-                        Object.assign(parentEntity, { [rel.propertyName]: entities });
-                    }
-                    else {
-                        Object.assign(parentEntity, {
-                            [rel.propertyName]: (0, utils_1.tableItemToEntity)(rel.target, tableItem)
-                        });
-                    }
-                }
+        relatedEntities.forEach(entity => {
+            const rel = relationsLookup[entity.type];
+            if (rel.type === "HasMany" || rel.type === "HasAndBelongsToMany") {
+                const entities = parentEntity[rel.propertyName];
+                if (Array.isArray(entities))
+                    entities.push(entity);
+                Object.assign(parentEntity, { [rel.propertyName]: entities });
+            }
+            else {
+                Object.assign(parentEntity, { [rel.propertyName]: entity });
             }
         });
         return parentEntity;
@@ -232,8 +145,6 @@ class FindById extends OperationBase_1.default {
      */
     setIncludedRelationshipDefaults(parentEntity, relationsLookup) {
         Object.values(relationsLookup).forEach(rel => {
-            if (!(0, utils_1.isKeyOfEntity)(parentEntity, rel.propertyName))
-                return;
             if ((0, utils_3.isHasManyRelationship)(rel) ||
                 (0, utils_3.isHasAndBelongsToManyRelationship)(rel)) {
                 (0, utils_1.safeAssign)(parentEntity, rel.propertyName, []);

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

@@ -1,7 +1,6 @@
-import type { QueryItems } from "../../dynamo-utils";
 import type DynaRecord from "../../DynaRecord";
-import type { EntityAttributes, FunctionFields, RelationshipAttributeNames } from "../types";
-import type { BelongsToLinkDynamoItem } from "../../types";
+import type { EntityAttributesOnly, FunctionFields, RelationshipAttributeNames } from "../types";
+import { type QueryResult, type QueryResults } from "../Query";
 /**
  * Defines options for the `FindById` operation, allowing specification of additional associations to include in the query result.
  *
@@ -21,14 +20,14 @@ export interface FindByIdOptions<T extends DynaRecord> {
  */
 export type IncludedAssociations<T extends DynaRecord> = NonNullable<FindByIdOptions<T>["include"]>;
 /**
- * Describes the structure of query results, sorting them into the main entity item and any associated `BelongsToLink` items. Used during processing
+ * Describes the structure of query results, sorting them into the main entity item and any associated items. Used during processing
  *
  * @property {QueryItems[number]} item - The main entity item retrieved from the query.
- * @property {BelongsToLinkDynamoItem[]} belongsToLinks - An array of `BelongsToLinkDynamoItem` instances associated with the main entity item.
+ * @property {QueryItems[]} relatedEntities - An array of `denormalized records` instances associated with the main entity item.
  */
 export interface SortedQueryResults {
-    item: QueryItems[number];
-    belongsToLinks: BelongsToLinkDynamoItem[];
+    entity?: QueryResult<DynaRecord>;
+    relatedEntities: QueryResults<DynaRecord>;
 }
 /**
  * Derives the keys of included associations from `FindByIdOptions`, representing the names of relationships specified to be included in the query result.
@@ -44,7 +43,7 @@ type IncludedKeys<T extends DynaRecord, Opts extends FindByIdOptions<T>> = Opts
  * @template P - The properties of the entity `T`.
  */
 type EntityKeysWithIncludedAssociations<T extends DynaRecord, P extends keyof T> = {
-    [K in P]: T[K] extends DynaRecord ? EntityAttributes<T> : T[K] extends DynaRecord[] ? Array<EntityAttributes<T[K][number]>> : T[K];
+    [K in P]: T[K] extends DynaRecord ? EntityAttributesOnly<T> : T[K] extends DynaRecord[] ? Array<EntityAttributesOnly<T[K][number]>> : T[K];
 };
 /**
  * Represents the result of a `FindById` operation, including the main entity and any specified associated entities.
@@ -52,6 +51,6 @@ type EntityKeysWithIncludedAssociations<T extends DynaRecord, P extends keyof T>
  * @template T - The type of the main entity, extending `DynaRecord`.
  * @template Opts - The options for the `FindById` operation, specifying included associations.
  */
-export type FindByIdIncludesRes<T extends DynaRecord, Opts extends FindByIdOptions<T>> = EntityKeysWithIncludedAssociations<T, keyof EntityAttributes<T> | IncludedKeys<T, Opts> | FunctionFields<T>>;
+export type FindByIdIncludesRes<T extends DynaRecord, Opts extends FindByIdOptions<T>> = EntityKeysWithIncludedAssociations<T, keyof EntityAttributesOnly<T> | IncludedKeys<T, Opts> | FunctionFields<T>>;
 export {};
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/operations/FindById/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EACV,gBAAgB,EAChB,cAAc,EACd,0BAA0B,EAC3B,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAE3D;;;;;;GAMG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,UAAU;IACnD,OAAO,CAAC,EAAE,KAAK,CAAC;QAAE,WAAW,EAAE,0BAA0B,CAAC,CAAC,CAAC,CAAA;KAAE,CAAC,CAAC;CACjE;AAED;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,UAAU,IAAI,WAAW,CAClE,eAAe,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAC9B,CAAC;AAEF;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC;IACzB,cAAc,EAAE,uBAAuB,EAAE,CAAC;CAC3C;AAED;;;;;GAKG;AACH,KAAK,YAAY,CAAC,CAAC,SAAS,UAAU,EAAE,IAAI,SAAS,eAAe,CAAC,CAAC,CAAC,IACrE,IAAI,SAAS,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,GACrC,CAAC,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC,GACxD,KAAK,CAAC;AAEZ;;;;;GAKG;AACH,KAAK,kCAAkC,CACrC,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,MAAM,CAAC,IACf;KACD,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,UAAU,GAC7B,gBAAgB,CAAC,CAAC,CAAC,GACnB,CAAC,CAAC,CAAC,CAAC,SAAS,UAAU,EAAE,GACvB,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GACrC,CAAC,CAAC,CAAC,CAAC;CACX,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,CAC7B,CAAC,SAAS,UAAU,EACpB,IAAI,SAAS,eAAe,CAAC,CAAC,CAAC,IAC7B,kCAAkC,CACpC,CAAC,EACD,MAAM,gBAAgB,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CACtE,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/operations/FindById/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EACV,oBAAoB,EACpB,cAAc,EACd,0BAA0B,EAC3B,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,UAAU,CAAC;AAE/D;;;;;;GAMG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,UAAU;IACnD,OAAO,CAAC,EAAE,KAAK,CAAC;QAAE,WAAW,EAAE,0BAA0B,CAAC,CAAC,CAAC,CAAA;KAAE,CAAC,CAAC;CACjE;AAED;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,UAAU,IAAI,WAAW,CAClE,eAAe,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAC9B,CAAC;AAEF;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC;IACjC,eAAe,EAAE,YAAY,CAAC,UAAU,CAAC,CAAC;CAC3C;AAED;;;;;GAKG;AACH,KAAK,YAAY,CAAC,CAAC,SAAS,UAAU,EAAE,IAAI,SAAS,eAAe,CAAC,CAAC,CAAC,IACrE,IAAI,SAAS,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,GACrC,CAAC,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC,GACxD,KAAK,CAAC;AAEZ;;;;;GAKG;AACH,KAAK,kCAAkC,CACrC,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,MAAM,CAAC,IACf;KACD,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,UAAU,GAC7B,oBAAoB,CAAC,CAAC,CAAC,GACvB,CAAC,CAAC,CAAC,CAAC,SAAS,UAAU,EAAE,GACvB,KAAK,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GACzC,CAAC,CAAC,CAAC,CAAC;CACX,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,CAC7B,CAAC,SAAS,UAAU,EACpB,IAAI,SAAS,eAAe,CAAC,CAAC,CAAC,IAC7B,kCAAkC,CACpC,CAAC,EACD,MAAM,oBAAoB,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAC1E,CAAC"}

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

@@ -14,7 +14,7 @@ declare class Query<T extends DynaRecord> extends OperationBase<T> {
      * Run the query operation
      * @param key EntityId or object with PartitionKey and optional SortKey conditions
      * @param options Filter conditions, indexName, or SortKey conditions if querying by keys
-     * @returns Array of Entity or BelongsToLinks
+     * @returns Array of Entity or denormalized records
      */
     run(key: string | EntityKeyConditions<T>, options?: QueryBuilderOptions | Omit<QueryOptions, "indexName">): Promise<QueryResults<T>>;
     /**
@@ -40,6 +40,7 @@ declare class Query<T extends DynaRecord> extends OperationBase<T> {
      * @returns
      */
     private resolveQueryResults;
+    private tableItemToLinkedEntity;
 }
 export default Query;
 //# sourceMappingURL=Query.d.ts.map