Topic

Entities

Definition

A TypeORM entity is a TypeScript class decorated with @Entity whose properties, marked with column decorators such as @Column, @PrimaryGeneratedColumn, @CreateDateColumn, and @UpdateDateColumn, map to the columns of a single database table.

In simpler words

An entity is the SQL table from earlier, written as a typed class so the rest of the app can read and write rows as objects instead of raw SQL strings.

User and Ticket are the example entities behind the users/tickets rows you have already seen in raw SQL.

Open official example (opens in new tab)

After this you can

Map every column decorator in User/Ticket back to its SQL column
Explain what @PrimaryGeneratedColumn('uuid') and the date columns generate
Recognize column options (unique, nullable, default, length) as the TypeScript form of SQL constraints

@Entity and @Column map class to table

Definition

@Entity({ name: ... }) associates a class with a specific table name, and @Column (with options) associates a property with a specific column, its type, and its constraints.

In simpler words

Read an entity top-to-bottom and you are reading the same information as the CREATE TABLE statement, just in TypeScript.

User maps to the users table; every @Column here corresponds 1:1 to a column you already saw in the initial schema.

Column options mirror SQL constraints: unique, nullable, default, length, and an explicit type when it differs from the TypeScript type.

User entity

@Entity({ name: 'users' })
export class User {
  @PrimaryGeneratedColumn('uuid')
  id!: string;

  @Column({ unique: true })
  email!: string;

  @Column({ name: 'password_hash' })
  passwordHash!: string;

  @Column({ type: 'varchar', length: 20, default: 'member' })
  role!: UserRole;
}

@Column({ name: 'password_hash' }) maps a camelCase property to a snake_case column — property and column names do not have to match.

Generated and timestamp columns

Definition

@PrimaryGeneratedColumn generates a primary key value automatically on insert, and @CreateDateColumn / @UpdateDateColumn automatically populate creation and last-modified timestamps without application code setting them.

In simpler words

These decorators exist so nobody has to remember to set id, created_at, or updated_at by hand on every insert or update.

@PrimaryGeneratedColumn('uuid') tells TypeORM (and the migration it generates) to default the column to a generated UUID, matching gen_random_uuid() in SQL.

@UpdateDateColumn refreshes its value on every save() — this is how Ticket.updatedAt stays accurate without manual bookkeeping.

Ticket entity timestamps

@Entity({ name: 'tickets' })
export class Ticket {
  @PrimaryGeneratedColumn('uuid')
  id!: string;

  @Column({ length: 200 })
  title!: string;

  @Column({ type: 'text', nullable: true })
  description!: string | null;

  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
  createdAt!: Date;

  @UpdateDateColumn({ name: 'updated_at', type: 'timestamptz' })
  updatedAt!: Date;
}

description is explicitly nullable — its TypeScript type says so too (string | null).

Column options are SQL constraints, spelled in TypeScript

Definition

Column decorator options (unique, nullable, default, length, type) directly control the constraints and type that TypeORM will generate in a migration for that column.

In simpler words

Every option you set here should have a reason traceable to a real business rule, the same discipline as choosing raw SQL types and constraints.

unique: true on email is exactly UNIQUE ("email") in SQL — TypeORM will name the constraint and generate it in a migration.

nullable: true is the TypeScript-side way of omitting NOT NULL for a column, as seen on Ticket.description and Ticket.assigneeId.

Nullable foreign key column

@Column({ name: 'assignee_id', type: 'uuid', nullable: true })
assigneeId!: string | null;

nullable: true here matches the SQL column having no NOT NULL — an unassigned ticket is valid.

Keep in mind

When in doubt about a column’s real SQL shape, compare the entity decorator to the migration SQL — they must agree.
Never hand-set a value that a generated or timestamp column owns.
A mismatched nullable/type between entity and actual column is a common source of confusing runtime errors.

Test

Check your understanding

At least 10 questions — mix of concept, syntax, practical, and logic. Score ≥80% (enforced by the API) to save progress.

Checking your session…

15 questions · concept 5 · syntax 3 · practical 4 · logic 3

1. What does @Entity mark?

Concept

A class mapped to a database tableA class that becomes a REST controller for that tableA class whose properties become request validation rulesA class TypeORM instantiates once as a singleton service

2. What does @Column mark?

Syntax

A property mapped to a table columnA property that is validated but never persistedA computed property derived from other columns at query timeA property that creates its own index automatically

3. Must entities extend a TypeORM base class?

Practical

Yes — every entity must extend AbstractEntity for timestampsYes — extend Repository so the entity can query itselfNo — plain classes with decorators are enoughOnly entities that declare relations must extend BaseEntity

4. Does @Entity create the table by itself?

Logic

Yes — TypeORM issues CREATE TABLE the first time the class loadsNo — schema still comes from migrations (or synchronize if enabled)Yes — the table appears on the first repository.save callYes — but only the columns, not the constraints

5. How do you map a custom column name?

Concept

Add a @ColumnName decorator above the propertyMatch the property name to the SQL name using camelCase automaticallyDeclare the SQL name in the @Entity table optionsPass name in @Column/{ name: ... } or relation JoinColumn

6. What are nullable columns in entities?

Practical

Properties marked optional with ? that TypeORM makes nullable automaticallyProperties without a @Column decorator so they stay unpersistedProperties typed to allow null and column nullable:true when neededProperties given a DEFAULT of null in the column options

7. Where should password hashes live relative to API responses?

Syntax

On the entity and included in responses, since the hash is not reversibleOnly in the JWT payload, never stored in the databaseOn the entity for persistence, omitted from public response mappingIn a plaintext column so the login endpoint can compare directly

8. Can entities include relations?

Logic

Only if you also define them in a separate migration fileYes — @ManyToOne/@OneToMany and friendsOnly through raw foreign key columns, not relation decoratorsYes, but each entity may declare at most one relation

9. What is a primary column typically?

Concept

@Column({ primary: false }) on the id field@Index({ unique: true }) on the id field@PrimaryGeneratedColumn or @PrimaryColumn on the id field@Generated() alone on the id field

10. Why keep entities free of HTTP concerns?

Practical

Because TypeORM strips any HTTP decorators before savingSo the same entity can be reused as the request DTO directlyEntities model persistence; controllers/DTOs shape HTTPBecause entities run in the browser where HTTP is unavailable

11. What table and columns does this entity map to?

Conceptintermediate

@Entity('tickets')
export class Ticket {
  @PrimaryGeneratedColumn('uuid')
  id: string;

  @Column({ nullable: true })
  assigneeId: string | null;
}

A tickets table with a generated uuid id and a nullable assigneeId columnA tickets table where both id and assigneeId are NOT NULLA Ticket table (matching the class name) with a required assigneeIdA tickets table with an auto-increment integer id, not a uuid

12. You want passwordHash excluded from normal finds. Which change does that at the entity level?

Syntaxadvanced

@Column()
passwordHash: string;

Add @Column({ nullable: true }) so it is skipped when emptySet @Column({ select: false }) so it is not loaded unless explicitly requestedMark it @Column({ default: null }) to hide it from queriesUse @Exclude() from class-transformer to drop it from the SQL SELECT

13. What does nullable: true mean for this column?

Practicalintermediate

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

The column defaults to an empty string when no value is givenThe column allows NULL, so the value is optionalThe property may be omitted from the entity class entirelyNULL values are stored but hidden from SELECT results

14. Does defining this entity create the tickets table?

Logicadvanced

@Entity('tickets')
export class Ticket {
  @PrimaryGeneratedColumn()
  id: number;
}

Yes, the @Entity name triggers a CREATE TABLE at startupYes, on the first findOne call against the repositoryYes, but only in production buildsNo — schema comes from migrations (or synchronize); the entity is only metadata

15. What does this decorator do?

Conceptintermediate

@PrimaryGeneratedColumn('uuid')
id: string;

Marks id as a primary key you must supply on each insertMarks id as the primary key with an auto-generated uuidGenerates a sequential integer id instead of a uuidMarks id as unique but leaves the table without a primary key

Checking your session…