Class default`Abstract`

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

DynaRecordBase

Index

Constructors

constructor

new default(): default
Returns default

Properties

`Readonly`createdAt

createdAt: Date

The timestamp marking when the entity was created

`Readonly`id

id: string

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

`Readonly`type

type: string

The type of the Entity

`Readonly`updatedAt

updatedAt: Date

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

Methods

partitionKeyValue

partitionKeyValue(): string
Returns string
- Defined in src/DynaRecord.ts:382

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
- T extends default
Parameters
- attributes: Partial<AllowNullForNullable<EntityDefinedAttributes<T>>>
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 });
```
- Defined in src/DynaRecord.ts:328

`Static`create

create<T extends default>(
this: EntityClass<T>,
attributes: CreateOptions<T>,
): Promise<Promise<EntityAttributesOnly<T>>>
Create an entity. If foreign keys are included in the attributes then links will be demoralized accordingly
Type Parameters
- T extends default
Parameters
- this: EntityClass<T>
- attributes: CreateOptions<T>
  Attributes of the model to create
Returns Promise<Promise<EntityAttributesOnly<T>>>
The new Entity
```
const newUser = await User.create({ name: "Alice", email: "alice@example.com", profileId: "123" });
```
- Defined in src/DynaRecord.ts:277

`Static`delete

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
- T extends default
Parameters
- this: EntityClass<T>
- id: string
  The id of the entity to update
Returns Promise<void>
Example: Delete an entity
```
await User.delete("userId");
```
- Defined in src/DynaRecord.ts:359

`Static`findById

findById<T extends default>(
    this: EntityClass<T>,
    id: string,
    options?: undefined,
): Promise<Optional<EntityInstance<T>>>
Find an entity by Id and optionally include associations.
Type Parameters
- T extends default
Parameters
- this: EntityClass<T>
- id: string
  Entity Id.
- Optionaloptions: undefined
  No options provided, returns the entity without included associations.
Returns Promise<Optional<EntityInstance<T>>>
An entity without included associations serialized.
Example: Without included relationships
```
const user = await User.findById("userId");
```
Example: With included relationships
```
const user = await User.findById("userId", { include: [{ association: "profile" }] });
```
- Defined in src/DynaRecord.ts:105
findById<T extends default, Inc extends IncludedAssociations<T> = []>(
    this: EntityClass<T>,
    id: string,
    options: FindByIdOptions<T, Inc>,
): Promise<Optional<FindByIdIncludesRes<T, Inc>>>
Find an entity by Id and optionally include associations.
Type Parameters
- T extends default
- Inc extends IncludedAssociations<T> = []
Parameters
- this: EntityClass<T>
- id: string
  Entity Id.
- options: FindByIdOptions<T, Inc>
  No options provided, returns the entity without included associations.
Returns Promise<Optional<FindByIdIncludesRes<T, Inc>>>
An entity without included associations serialized.
Example: Without included relationships
```
const user = await User.findById("userId");
```
Example: With included relationships
```
const user = await User.findById("userId", { include: [{ association: "profile" }] });
```
- Defined in src/DynaRecord.ts:112

`Static`partitionKeyValue

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");
```
- Defined in src/DynaRecord.ts:377

`Static`query

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
- T extends default
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 })
```
- Defined in src/DynaRecord.ts:171
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

T extends default

Parameters

this: EntityClass<T>
key: EntityKeyConditions<T>
PartitionKey value and optional SortKey condition. Keys must be attributes defined on the model
Optionaloptions: OptionsWithoutIndex
QueryBuilderOptions

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
- T extends default
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" }
 );
```
- Defined in src/DynaRecord.ts:253

`Static`update

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
  - If the foreign key is not nullable then a NullConstraintViolationError is thrown.
- Validation errors will be thrown if the attribute being removed is not nullable
Type Parameters
- T extends default
Parameters
- this: EntityClass<T>
- id: string
  The id of the entity to update
- attributes: Partial<AllowNullForNullable<EntityDefinedAttributes<T>>>
  Attributes to update
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 });
```
- Defined in src/DynaRecord.ts:305

Class defaultAbstract

Example

Implements

Index

Constructors

Properties

Methods

Constructors

constructor

Returns default

Properties

ReadonlycreatedAt

Readonlyid

Readonlytype

ReadonlyupdatedAt

Methods

partitionKeyValue

Returns string

update

Type Parameters

Parameters

Returns Promise<T>

Example: Updating an entity.

Example: Removing a nullable entities attributes

Staticcreate

Type Parameters

Parameters

Returns Promise<Promise<EntityAttributesOnly<T>>>

Staticdelete

Type Parameters

Parameters

Returns Promise<void>

Example: Delete an entity

StaticfindById

Type Parameters

Parameters

Returns Promise<Optional<EntityInstance<T>>>

Example: Without included relationships

Example: With included relationships

Type Parameters

Parameters

Returns Promise<Optional<FindByIdIncludesRes<T, Inc>>>

Example: Without included relationships

Example: With included relationships

StaticpartitionKeyValue

Parameters

Returns string

Example

Staticquery

Type Parameters

Parameters

Returns Promise<QueryResults<T>>

Example: By partition key only

Example: By partition key and sort key exact match

Example: By partition key and sort key begins with

Example: With filter (arbitrary example)

Type Parameters

Parameters

Returns Promise<QueryResults<T>>

Example: By partition key only

Example: By partition key and sort key exact match

Example: By partition key and sort key begins with

Example: With filter (arbitrary example)

Example: With a consistent read

Type Parameters

Parameters

Returns Promise<QueryResults<T>>

Example: On index

Staticupdate

Type Parameters

Parameters

Returns Promise<void>

Example: Updating an entity.

Example: Removing a nullable entities attributes

Settings

On This Page

Class default`Abstract`

`Readonly`createdAt

`Readonly`id

`Readonly`type

`Readonly`updatedAt

`Static`create

`Static`delete

`Static`findById

`Static`partitionKeyValue

`Static`query

`Static`update