Decorators

InjectDatabase(token?: DatabaseBinding | TypedInjectionKey<unknown>): TypedParameterDecorator<OrmDatabase>

@Injectable()
export class ReportService {
    constructor(@InjectDatabase() private database: OrmDatabase) {}

    async count(): Promise<number> {
        return await this.database.getRepository(Order).count();
    }
}

InjectRepository(entity: Constructor<EntityType>, token?: DatabaseBinding | TypedInjectionKey<unknown>): TypedParameterDecorator<OrmRepository<EntityType>>

@Injectable()
export class BookService {
    constructor(
        @InjectRepository(Book) private books: OrmRepository<Book>,
    ) {}

    async get(id: string): Promise<Book | undefined> {
        return await this.books.findOne({ where: { id } });
    }
}

OrmAfterDelete(): PropertyDecorator

@OrmAfterDelete()
logDeletion(): void {
    console.log(`deleted ${this.id}`);
}

OrmAfterInsert(): PropertyDecorator

@OrmAfterInsert()
logCreation(): void {
    console.log(`created ${this.id}`);
}

OrmAfterLoad(): PropertyDecorator

@OrmAfterLoad()
computeDisplayName(): void {
    this.displayName = `${this.firstName} ${this.lastName}`;
}

OrmAfterUpdate(): PropertyDecorator

@OrmAfterUpdate()
invalidateCache(): void {
    this.cachedSummary = undefined;
}

OrmBeforeDelete(): PropertyDecorator

@OrmBeforeDelete()
assertDeletable(): void {
    if (this.locked) throw new Error('Cannot delete a locked row.');
}

OrmBeforeInsert(): PropertyDecorator

@OrmBeforeInsert()
normalizeEmail(): void {
    this.email = this.email.trim().toLowerCase();
}

OrmBeforeUpdate(): PropertyDecorator

@OrmBeforeUpdate()
bumpRevision(): void {
    this.revision += 1;
}

OrmColumn(kind: OrmColumnType, options?: OrmColumnOptions<T>): PropertyDecorator

@OrmColumn({ kind: 'varchar', length: 255 })
declare title: string;

@OrmColumn({ kind: 'varchar', length: 13 }, { unique: true })
declare isbn: string;

@OrmColumn({ kind: 'integer' }, { nullable: true })
declare pages: number | null;

OrmColumnIndex(name?: string): PropertyDecorator

class User {
  @OrmColumn({ kind: 'varchar', length: 36 })
  @OrmColumnIndex() // Auto-generates: idx_user_accountId
  declare accountId: string;

  @OrmColumn({ kind: 'varchar', length: 100 })
  @OrmColumnIndex('idx_user_email') // Custom name
  declare email: string;
}

OrmColumnUnique(name?: string): PropertyDecorator

class User {
  @OrmColumn({ kind: 'varchar', length: 100 })
  @OrmColumnUnique() // Auto-generates: unq_user_email
  declare email: string;

  @OrmColumn({ kind: 'varchar', length: 50 })
  @OrmColumnUnique('unq_username') // Custom name
  declare username: string;
}

OrmColumnUniqueIndex(name?: string): PropertyDecorator

class User {
  @OrmColumn({ kind: 'varchar', length: 100 })
  @OrmColumnUniqueIndex() // Auto-generates: unq_idx_user_email
  declare email: string;

  @OrmColumn({ kind: 'varchar', length: 50 })
  @OrmColumnUniqueIndex('unq_idx_custom_username') // Custom name
  declare username: string;
}

OrmCreateDateColumn(options?: OrmColumnOptions): PropertyDecorator

@OrmCreateDateColumn()
declare createdAt: Date;

OrmJoinColumn(options?: OrmJoinColumnOptions): PropertyDecorator

class Post {
  @OrmManyToOne(() => User)
  @OrmJoinColumn({ name: 'author_id', nullable: false })
  author: User;
}

OrmManyToOne(target: () => Constructor<TargetType>, options?: OrmManyToOneOptions<TargetType>): PropertyDecorator

class Post {
  @OrmManyToOne(() => User, { joinColumn: 'authorId' })
  author: User;
}

OrmOneToMany(target: () => Constructor<TargetType>, options: OrmOneToManyOptions<TargetType>): PropertyDecorator

class User {
  @OrmOneToMany(() => Post, { inverseSide: 'author' })
  posts: Post[];
}

OrmOneToOne(target: () => Constructor<TargetType>, options?: OrmOneToOneOptions<TargetType>): PropertyDecorator

class User {
  @OrmOneToOne(() => Profile, { joinColumn: 'profileId' })
  profile: Profile;
}

OrmPrimaryAutoColumn(strategy: "uuid"): PropertyDecorator

OrmPrimaryAutoColumn(strategy: "serial", size?: OrmIntegerSizeType): PropertyDecorator

@OrmPrimaryAutoColumn('uuid')
declare id: string;

OrmPrimaryKey(columns: string[], options?: OrmPrimaryKeyOptions): (ctor: T) => void

// A junction table with a composite key
@OrmTable('book_genres')
@OrmPrimaryKey(['bookId', 'genreId'])
export class BookGenre extends OrmTrackingEntity {
    @OrmColumn({ kind: 'varchar', length: 36 })
    declare bookId: string;

    @OrmColumn({ kind: 'varchar', length: 36 })
    declare genreId: string;
}

OrmTable(name?: string, options?: OrmTableOptions): (ctor: T) => void

@OrmTable('books')
export class Book extends OrmTrackingEntity {
    @OrmPrimaryAutoColumn('uuid')
    declare id: string;

    @OrmColumn({ kind: 'varchar', length: 255 })
    declare title: string;

    @OrmCreateDateColumn()
    declare createdAt: Date;
}

OrmTableIndex(columns: OrmIndexColumn[], options?: OrmTableIndexOptions): (ctor: T) => void

OrmTableIndex(name: string, columns: OrmIndexColumn[], options?: OrmTableIndexOptions): (ctor: T) => void

@OrmTable('orders')
@OrmTableIndex(['orderDate'])
export class Order extends OrmTrackingEntity { ... }

OrmTableUnique(columns: string[]): (ctor: T) => void

OrmTableUnique(name: string, columns: string[]): (ctor: T) => void

// Auto-generated name: uc_user_email_username
@OrmTableUnique(['email', 'username'])
class User {
  // ...
}

OrmTableUniqueIndex(columns: string[], options?: OrmTableIndexOptions): (ctor: T) => void

OrmTableUniqueIndex(name: string, columns: string[], options?: OrmTableIndexOptions): (ctor: T) => void

@OrmTable('members')
@OrmTableUniqueIndex(['organizationId', 'accountId'])
export class Member extends OrmTrackingEntity { ... }

OrmUpdateDateColumn(options?: OrmColumnOptions): PropertyDecorator

@OrmUpdateDateColumn()
declare updatedAt: Date;