Entities

INFO

Column names, are transformed to snake_case by our naming strategy.

Entities are the backbone of your application's data structure, representing the objects within your domain and their relationships. They define the structure, behavior, and constraints of the data in your system. In a typical application, entities correspond to database tables and their fields.

Let's take a look at an example entity, user.entity.ts, and analyze its various components:

@Entity()
export class User {
  @PrimaryGeneratedColumn('uuid')
  uuid: string;

  @CreateDateColumn({ precision: 3 })
  createdAt: Date;

  @UpdateDateColumn({ precision: 3 })
  updatedAt: Date;

  @Column({ type: 'varchar', unique: true })
  email: string;

  @Column({ type: 'varchar' })
  password: string;

  @Column({ type: 'varchar', nullable: true })
  firstName: string | null;

  @Column({ type: 'varchar', nullable: true })
  lastName: string | null;
}

In this example, we use the typeorm library to define the User entity. The @Entity() decorator indicates that this class represents a database entity, i.e., a table in the database.

The User entity has several properties, each with their respective decorators:

1. uuid: A unique identifier for the user. The decorator specifies that this column is the primary key for the table and its value should be generated automatically as a UUID.
2. createdAt: The date and time when the entity was created. The decorator indicates that this column should store the creation timestamp with a precision of 3 decimals.
3. updatedAt: The date and time when the entity was last updated.
4. email: The user's email address. The decorator specifies that this column should store a variable-length string and be unique across all users.
5. firstName: The user's first name, which is nullable. The decorator indicates that this column should store a variable-length string and can be null.
6. lastName: The user's last name, which is nullable. The decorator indicates that this column should store a variable-length string and can be null.

By defining the structure of the User entity, we ensure that the application follows a consistent representation of users, which facilitates data validation, querying, and manipulation.