Class defaultAbstract

Serves as an abstract base class for entities in the ORM system. It defines standard fields such as id, type, createdAt, and updatedAt, and provides static methods for CRUD operations and queries. This class encapsulates common behaviors and properties that all entities share, leveraging decorators for attribute metadata and supporting operations like finding, creating, updating, and deleting entities.

Table classes should extend this class, and each entity should extend the table class

Entities extending DynaRecord can utilize these operations to interact with their corresponding records in the database, including handling relationships between different entities.

Example

@Table({ name: "my-table" })
abstract class MyTable extends DynaRecord {
  @PartitionKeyAttribute()
  public readonly pk: PartitionKey;

  @SortKeyAttribute()
  public readonly sk: SortKey;
}

@Entity
class User extends MyTable {
 // User implementation
}

Implements

Constructors

constructor

Properties

createdAt id type updatedAt

Methods

partitionKeyValue update create delete findById partitionKeyValue query update

Constructors

constructor

Properties

ReadonlycreatedAt

createdAt: Date

The timestamp marking when the entity was created

Readonlyid

id: string

A unique identifier for the entity itself, automatically generated upon creation.

Readonlytype

type: string

The type of the Entity

ReadonlyupdatedAt

updatedAt: Date

The timestamp marking the last update to the entity. Initially set to the same value as createdAt.

Methods

partitionKeyValue

update

  • update<T extends default>(
        attributes: Partial<AllowNullForNullable<EntityDefinedAttributes<T>>>,
    ): Promise<T>

  • Same as the static update method but on an instance. Returns the full updated instance

    Type Parameters

    Parameters

    Returns Promise<T>

    Example: Updating an entity.

    const updatedInstance = await instance.update({ email: "newemail@example.com", profileId: 789 });

    Example: Removing a nullable entities attributes

    const updatedInstance = await instance.update({ email: "newemail@example.com", someKey: null });

Staticcreate

Staticdelete

  • delete<T extends default>(this: EntityClass<T>, id: string): Promise<void>

  • Delete an entity by ID

    • Delete all denormalized records
    • Disassociate all foreign keys of linked models

    Type Parameters

    Parameters

    • this: EntityClass<T>
    • id: string

      The id of the entity to update

    Returns Promise<void>

    Example: Delete an entity

    await User.delete("userId");

StaticfindById

StaticpartitionKeyValue

  • partitionKeyValue(id: string): string

  • Constructs the partition key value

    Parameters

    • id: string

      Entity Id

    Returns string

    Constructed partition key value

    Example

    const pkValue = User.partitionKeyValue("userId");

Staticquery

  • query<T extends default>(
        this: EntityClass<T>,
        key: string,
        options?: OptionsWithoutIndex,
    ): Promise<QueryResults<T>>

  • Query an EntityPartition by EntityId and optional SortKey/Filter conditions. QueryByIndex not supported. Use Query with keys if indexName is needed

    Type Parameters

    Parameters

    • this: EntityClass<T>
    • key: string
    • Optionaloptions: OptionsWithoutIndex

      QueryOptions. Supports filter, consistentRead and skCondition. indexName is not supported

    Returns Promise<QueryResults<T>>

    Example: By partition key only

    const user = await User.query("123");

    Example: By partition key and sort key exact match

    const user = await User.query("123", { skCondition: "Profile#111" });

    Example: By partition key and sort key begins with

    const user = await User.query("123", { skCondition: { $beginsWith: "Profile" } })

    Example: With filter (arbitrary example)

    const user = await User.query("123", {
      filter: {
        type: "Profile",
        createdAt: "2023-11-21T12:31:21.148Z"
       }
    });

    @example Query as consistent read
    ```typescript
    const user = await User.query("123", { consistentRead: true })
  • query<T extends default>(
        this: EntityClass<T>,
        key: EntityKeyConditions<T>,
        options?: OptionsWithoutIndex,
    ): Promise<QueryResults<T>>

  • Query by PartitionKey and optional SortKey/Filter/Index conditions without and index When querying without an index the key conditions must be the PartitionKey and SortKey defined on the entity

    Type Parameters

    Parameters

    Returns Promise<QueryResults<T>>

    Example: By partition key only

    const user = await User.query({ pk: "User#123" });

    Example: By partition key and sort key exact match

    const user = await User.query({ pk: "User#123", sk: "Profile#123" });

    Example: By partition key and sort key begins with

    const user = await User.query({ pk: "User#123", sk: { $beginsWith: "Profile" } });

    Example: With filter (arbitrary example)

    const result = await User.query(
     {
       myPk: "User|123"
     },
     {
       filter: {
         type: ["Profile", "Preferences"],
         createdAt: { $beginsWith: "2023" },
         $or: [
           {
            name: "John",
            email: { $beginsWith: "testing }
           },
           {
             name: "Jane",
             updatedAt: { $beginsWith: "2024" },
           },
          {
            id: "123"
          }
         ]
       }
    }
    );

    Example: With a consistent read

    const user = await User.query({ pk: "User#123", consistentRead: true });
  • query<T extends default>(
        this: EntityClass<T>,
        key: IndexKeyConditions<T>,
        options: {
            consistentRead?: undefined;
            filter?: FilterParams;
            indexName: string;
        },
    ): Promise<QueryResults<T>>

  • Query by PartitionKey and optional SortKey/Filter/Index conditions with an index When querying on an index, any of the entities attributes can be part of the key condition

    Type Parameters

    Parameters

    • this: EntityClass<T>
    • key: IndexKeyConditions<T>

      Any attribute defined on the entity that is part of an index's keys

    • options: { consistentRead?: undefined; filter?: FilterParams; indexName: string }

      QueryBuilderOptions

    Returns Promise<QueryResults<T>>

    Example: On index

     const result = await User.query(
       {
         name: "SomeName" // An attribute that is part of the key condition on an iondex
       },
       { indexName: "myIndex" }
     );

Staticupdate

  • update<T extends default>(
        this: EntityClass<T>,
        id: string,
        attributes: Partial<AllowNullForNullable<EntityDefinedAttributes<T>>>,
    ): Promise<void>

  • Update an entity. If foreign keys are included in the attribute then:

    • Manages associated relationship links as needed
    • If the entity already had a foreign key relationship, then denormalized records will be deleted from each partition
    • Validation errors will be thrown if the attribute being removed is not nullable

    Type Parameters

    Parameters

    Returns Promise<void>

    Example: Updating an entity.

    await User.update("userId", { email: "newemail@example.com", profileId: 789 });

    Example: Removing a nullable entities attributes

    await User.update("userId", { email: "newemail@example.com", someKey: null });

Settings

Member Visibility

On This Page

Constructors
Properties
Methods