dyna-record 0.0.1

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

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const uuid_1 = require("uuid");
+const dynamo_utils_1 = require("../../dynamo-utils");
+const utils_1 = require("../../utils");
+const OperationBase_1 = __importDefault(require("../OperationBase"));
+const utils_2 = require("../utils");
+/**
+ * Represents the operation for creating a new entity in the database, including handling its attributes and any related entities' associations. It will handle de-normalizing data to support relationships
+ *
+ * It encapsulates the logic required to translate entity attributes to a format suitable for DynamoDB, execute the creation transaction, and manage any relationships defined by the entity, such as "BelongsTo" or "HasMany" links.
+ *
+ * @template T - The type of the entity being created, extending `DynaRecord`.
+ */
+class Create extends OperationBase_1.default {
+    #transactionBuilder;
+    constructor(Entity) {
+        super(Entity);
+        this.#transactionBuilder = new dynamo_utils_1.TransactWriteBuilder();
+    }
+    /**
+     * Create an entity transaction, including relationship transactions (EX: Creating BelongsToLinks for HasMany, checking existence of relationships, etc)
+     * @param attributes
+     * @returns
+     */
+    async run(attributes) {
+        const entityData = this.buildEntityData(attributes);
+        const tableItem = (0, utils_1.entityToTableItem)(this.EntityClass, entityData);
+        this.buildPutItemTransaction(tableItem);
+        await this.buildRelationshipTransactions(entityData);
+        await this.#transactionBuilder.executeTransaction();
+        return (0, utils_1.tableItemToEntity)(this.EntityClass, tableItem);
+    }
+    /**
+     * Builds the entity attributes
+     * @param attributes
+     * @returns
+     */
+    buildEntityData(attributes) {
+        const id = (0, uuid_1.v4)();
+        const createdAt = new Date();
+        const pk = this.tableMetadata.partitionKeyAttribute.name;
+        const sk = this.tableMetadata.sortKeyAttribute.name;
+        const keys = {
+            [pk]: this.EntityClass.partitionKeyValue(id),
+            [sk]: this.EntityClass.name
+        };
+        const defaultAttrs = {
+            id,
+            type: this.EntityClass.name,
+            createdAt,
+            updatedAt: createdAt
+        };
+        return { ...keys, ...attributes, ...defaultAttrs };
+    }
+    /**
+     * Build the transaction for the parent entity Create item request
+     * @param tableItem
+     */
+    buildPutItemTransaction(tableItem) {
+        const { name: tableName } = this.tableMetadata;
+        const putExpression = {
+            TableName: tableName,
+            Item: tableItem,
+            ConditionExpression: `attribute_not_exists(${this.partitionKeyAlias})` // Ensure item doesn't already exist
+        };
+        this.#transactionBuilder.addPut(putExpression);
+    }
+    /**
+     * Build transaction items for associations
+     * @param entityData
+     */
+    async buildRelationshipTransactions(entityData) {
+        const relationshipTransactions = new utils_2.RelationshipTransactions({
+            Entity: this.EntityClass,
+            transactionBuilder: this.#transactionBuilder
+        });
+        await relationshipTransactions.build(entityData);
+    }
+}
+exports.default = Create;

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

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

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

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

package/dist/src/operations/Create/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.Create = void 0;
+var Create_1 = require("./Create");
+Object.defineProperty(exports, "Create", { enumerable: true, get: function () { return __importDefault(Create_1).default; } });
+__exportStar(require("./types"), exports);

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

@@ -0,0 +1,7 @@
+import type DynaRecord from "../../DynaRecord";
+import type { EntityDefinedAttributes } from "../types";
+/**
+ * Entity attribute fields that can be set on create. Excludes that are managed by dyna-record
+ */
+export type CreateOptions<T extends DynaRecord> = EntityDefinedAttributes<T>;
+//# sourceMappingURL=types.d.ts.map

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

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

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

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

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

@@ -0,0 +1,74 @@
+import DynaRecord from "../../DynaRecord";
+import type { EntityClass } from "../../types";
+import OperationBase from "../OperationBase";
+/**
+ * Implements the operation for deleting an entity and its related data from the database within the ORM framework.
+ *
+ * Delete an entity, everything in its partition, BelongsToLinks and nullifies ForeignKeys on attributes that BelongTo it
+ * 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.
+ *
+ * @template T - The type of the entity being deleted, extending `DynaRecord`.
+ */
+declare class Delete<T extends DynaRecord> extends OperationBase<T> {
+    #private;
+    constructor(Entity: EntityClass<T>);
+    /**
+     * Delete an item by id
+     *   - Deletes the given entity
+     *   - Deletes each item in the entity's partition
+     *   - For each item in the entity's partition which is of type 'BelongsToLink' it:
+     *     - Will nullify the associated relationship's ForeignKey attribute if the attribute is nullable
+     * @param id
+     */
+    run(id: string): Promise<void>;
+    /**
+     * Deletes an item
+     * @param item
+     */
+    private buildDeleteItemTransaction;
+    /**
+     * If the item has a JoinTable entry (is part of HasAndBelongsToMany relationship) then delete both JoinTable entries
+     * @param item - BelongsToLink from HasAndBelongsToMany relationship
+     */
+    private buildDeleteJoinTableLinkTransaction;
+    /**
+     * If the item being deleted has a foreign key reference, nullify the associated relationship's ForeignKey attribute
+     * If the ForeignKey is non nullable than it throws a NullConstraintViolationError
+     * @param item
+     */
+    private buildNullifyForeignKeyTransaction;
+    /**
+     * Deletes associated BelongsTo relationships for each ForeignKey of the item being deleted
+     * @param entityId
+     * @param item
+     */
+    private buildDeleteAssociatedBelongsTransaction;
+    /**
+     * Deletes associated BelongsToLink for a BelongsTo HasMany relationship
+     * @param relMeta
+     * @param entityId
+     * @param foreignKeyValue
+     */
+    private buildDeleteBelongsToHasManyTransaction;
+    /**
+     * Deletes associated BelongsToLink for a BelongsTo HasOne relationship
+     * @param relMeta
+     * @param foreignKeyValue
+     */
+    private buildDeleteBelongsToHasOneTransaction;
+    /**
+     * Type guard to check if the item being evaluated is the currentClass
+     * @param item
+     * @returns
+     */
+    private isEntityClass;
+    /**
+     * Track validation errors and throw AggregateError after all validations have been run
+     * @param err
+     */
+    private trackValidationError;
+}
+export default Delete;
+//# sourceMappingURL=Delete.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Delete.d.ts","sourceRoot":"","sources":["../../../../src/operations/Delete/Delete.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,kBAAkB,CAAC;AAc1C,OAAO,KAAK,EAAE,WAAW,EAAsB,MAAM,aAAa,CAAC;AAEnE,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAI7C;;;;;;;;;GASG;AACH,cAAM,MAAM,CAAC,CAAC,SAAS,UAAU,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC;;gBAS7C,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;IAiBlC;;;;;;;OAOG;IACU,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAyC3C;;;OAGG;IACH,OAAO,CAAC,0BAA0B;IAmBlC;;;OAGG;IACH,OAAO,CAAC,mCAAmC;IAoB3C;;;;OAIG;IACH,OAAO,CAAC,iCAAiC;IA0CzC;;;;OAIG;IACH,OAAO,CAAC,uCAAuC;IA0B/C;;;;;OAKG;IACH,OAAO,CAAC,sCAAsC;IAkB9C;;;;OAIG;IACH,OAAO,CAAC,qCAAqC;IAiB7C;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAIrB;;;OAGG;IACH,OAAO,CAAC,oBAAoB;CAG7B;AAED,eAAe,MAAM,CAAC"}

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

@@ -0,0 +1,207 @@
+"use strict";
+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 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
+ * 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.
+ *
+ * @template T - The type of the entity being deleted, extending `DynaRecord`.
+ */
+class Delete extends OperationBase_1.default {
+    #transactionBuilder;
+    #tableName;
+    #partitionKeyField;
+    #sortKeyField;
+    #relationsLookup;
+    #belongsToRelationships;
+    #validationErrors = [];
+    constructor(Entity) {
+        super(Entity);
+        this.#transactionBuilder = new dynamo_utils_1.TransactWriteBuilder();
+        const { name: tableName } = this.tableMetadata;
+        this.#tableName = tableName;
+        this.#partitionKeyField = this.tableMetadata.partitionKeyAttribute.name;
+        this.#sortKeyField = this.tableMetadata.sortKeyAttribute.name;
+        const relationsObj = (0, utils_3.buildEntityRelationshipMetaObj)(Object.values(this.entityMetadata.relationships));
+        this.#relationsLookup = relationsObj.relationsLookup;
+        this.#belongsToRelationships = relationsObj.belongsToRelationships;
+    }
+    /**
+     * 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:
+     *     - 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);
+            }
+        }
+        if (this.#validationErrors.length === 0) {
+            await this.#transactionBuilder.executeTransaction();
+        }
+        else {
+            throw new dynamo_utils_1.TransactionWriteFailedError(this.#validationErrors, "Failed Validations");
+        }
+    }
+    /**
+     * Deletes an item
+     * @param item
+     */
+    buildDeleteItemTransaction(item, options) {
+        const pkField = this.#partitionKeyField;
+        const skField = this.#sortKeyField;
+        this.#transactionBuilder.addDelete({
+            TableName: this.#tableName,
+            Key: {
+                [this.partitionKeyAlias]: item[pkField],
+                [this.sortKeyAlias]: item[skField]
+            }
+        }, 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
+     */
+    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)}`
+            });
+        }
+    }
+    /**
+     * If the item being deleted has a foreign key reference, nullify the associated relationship's ForeignKey attribute
+     * If the ForeignKey is non nullable than it throws a NullConstraintViolationError
+     * @param item
+     */
+    buildNullifyForeignKeyTransaction(item) {
+        const relMeta = this.#relationsLookup[item.foreignEntityType];
+        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}`);
+        }
+    }
+    /**
+     * Deletes associated BelongsTo relationships for each ForeignKey of the item being deleted
+     * @param entityId
+     * @param item
+     */
+    buildDeleteAssociatedBelongsTransaction(entityId, item) {
+        this.#belongsToRelationships.forEach(relMeta => {
+            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);
+                }
+            }
+        });
+    }
+    /**
+     * 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
+     */
+    isEntityClass(item) {
+        return item instanceof DynaRecord_1.default;
+    }
+    /**
+     * Track validation errors and throw AggregateError after all validations have been run
+     * @param err
+     */
+    trackValidationError(err) {
+        this.#validationErrors.push(err);
+    }
+}
+exports.default = Delete;

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

@@ -0,0 +1,2 @@
+export { default as Delete } from "./Delete";
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Delete = void 0;
+var Delete_1 = require("./Delete");
+Object.defineProperty(exports, "Delete", { enumerable: true, get: function () { return __importDefault(Delete_1).default; } });

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

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

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

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

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

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

@@ -0,0 +1,91 @@
+import type DynaRecord from "../../DynaRecord";
+import type { EntityClass, Optional } from "../../types";
+import OperationBase from "../OperationBase";
+import type { FindByIdOptions, FindByIdIncludesRes } from "./types";
+/**
+ * Facilitates the retrieval of an entity by its identifier (ID) from the database, potentially including its associated entities based on specified relationships.
+ *
+ * It supports fetching an entity solely by its ID or along with its related entities through specified associations, allowing for flexible retrieval of complex entity graphs in a single operation.
+ *
+ * @template T - The type of the entity being retrieved, extending `DynaRecord`.
+ */
+declare class FindById<T extends DynaRecord> extends OperationBase<T> {
+    #private;
+    constructor(Entity: EntityClass<T>);
+    /**
+     * Find an entity by Id and optionally include associations
+     * @param {string} id - Entity Id
+     * @param {Object} options - FindById options
+     * @param {Object[]=} options.include - The associations to include in the query
+     * @param {string} options.include[].association - The name of the association to include. Must be defined on the model
+     * @returns An entity with optional included associations serialized
+     */
+    run(id: string, options?: FindByIdOptions<T>): Promise<Optional<T | FindByIdIncludesRes<T, FindByIdOptions<T>>>>;
+    /**
+     * Find an Entity by id without associations
+     * @param {string} id - Entity Id
+     * @returns An entity object or undefined
+     */
+    private findByIdOnly;
+    /**
+     * Find an entity with included associations
+     * @param {string} id - Entity Id
+     * @param {Object[]=} includedAssociations - The associations to include in the query
+     * @param {string} includedAssociations[].association - The name of the association to include. Must be defined on the model
+     * @returns An entity with included associations serialized
+     */
+    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
+     * @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
+     * @returns
+     */
+    private getIncludedRelationships;
+    /**
+     * Serialize the FindById item to its class, serialize results from included relationships query onto the entity
+     * @param entityTableItem
+     * @param transactionResults
+     * @param relationsLookup
+     * @returns
+     */
+    private resolveFindByIdIncludesResults;
+    /**
+     * Initializes default values for included relationships on a parent entity. It assigns
+     * an empty array to each relationship property for HasMany and HasAndBelongsToMany specified in `relationsLookup` if the property exists on `parentEntity`.
+     *
+     * @param parentEntity - The parent entity to initialize relationship properties on.
+     * @param relationsLookup - A mapping of relationship identifiers to their descriptions, including the relationship
+     * type and the property name on the parent entity.
+     */
+    private setIncludedRelationshipDefaults;
+}
+export default FindById;
+//# sourceMappingURL=FindById.d.ts.map

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

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