typeorm#JoinTable TypeScript Examples

@JoinTable({
		name: "member_roles",
		joinColumn: { name: "index", referencedColumnName: "index" },
		inverseJoinColumn: {
			name: "role_id",
			referencedColumnName: "id",
		},
	})
	@ManyToMany(() => Role, { cascade: true })
	roles: Role[];

@ApiProperty({ type: type => License, isArray: true })
  @ManyToMany(type => License, license => license.obligations, {
    nullable: true,
  })
  @JoinTable({
    name: 'license_obligations_obligation',
    joinColumn: {
      name: 'obligationCode',
      referencedColumnName: 'code',
    },
    inverseJoinColumn: {
      name: 'licenseCode',
      referencedColumnName: 'code',
    },
  })
  licenses: License[];

/**
   * If the scan is granular, specifies organization tags that the
   * scan will run on.
   */
  @ManyToMany((type) => OrganizationTag, (tag) => tag.scans, {
    onDelete: 'CASCADE',
    onUpdate: 'CASCADE'
  })
  @JoinTable()
  tags: OrganizationTag[];

@ApiProperty({ description: 'Document type associated with the user' })
  @IsNotEmpty({
    message: 'The type of document is required'
  })
  @ManyToOne(() => DocumentType, documentType => documentType.users, {
    cascade: true
  })
  @JoinTable()
  documentType: DocumentType

@ManyToMany(() => Permission)
  @JoinTable({
    name: "permissions_roles",
    joinColumns: [{ name: "role_id" }],
    inverseJoinColumns: [{ name: "permission_id" }],
  })
  permission: Permission[];

@Field(() => [Team], { nullable: true })
  @JoinTable({ name: 'user_details_teams' })
  @ManyToMany(() => Team)
  teams?: Team[];

@ManyToMany(() => Scope, { onDelete: "CASCADE", onUpdate: "CASCADE" })
  @JoinTable({
    name: "oauth_token_scopes",
    joinColumn: { name: "tokenAccessToken", referencedColumnName: "accessToken" },
    inverseJoinColumn: { name: "scopeId", referencedColumnName: "id" },
  })
  scopes!: Scope[];

@JoinTable({ name: "message_stickers" })
	@ManyToMany(() => Sticker, { cascade: true, onDelete: "CASCADE" })
	sticker_items?: Sticker[];

@ManyToMany( () => Tag, ( tag ) => tag.products )
	@JoinTable( {
		name: 'product_tag',
		joinColumns: [ { name: 'productId', referencedColumnName: 'id' } ],
		inverseJoinColumns: [ { name: 'tagId', referencedColumnName: 'id' } ],
		schema: 'shop',
	} )
	tags: Tag[];

@Field(() => [KnowledgeSkillDetails], { nullable: true })
  @JoinTable({ name: 'grow_map_knowledge_skill_details' })
  @ManyToMany(() => KnowledgeSkillDetails, { onDelete: 'CASCADE' })
  knowledgeSkillDetails: KnowledgeSkillDetails[];

@ManyToMany(type => Student, student => student.subcourses, {
        eager: true
    })
    @JoinTable()
    instructors: Student[];

@ApiProperty({ description: 'Role associated with the user' })
  @ManyToOne(() => Role, role => role.users, {
    cascade: true
  })
  @JoinTable()
  role: Role

@ManyToMany(() => Role, role => role.users)
	@JoinTable({
		name: 'user_role'
	})
	public roles: Role[];

@OneToMany((type) => ContactAddress, (address) => address.contactInfo, { cascade: true, eager: true })
  @JoinTable()
  addresses: ContactAddress[];

@ManyToMany((type) => UserModel, (user) => user.queues)
  @JoinTable()
  staffList: UserModel[];

@Field((type) => [Cert])
  @ManyToMany((type) => Cert, (cert) => cert.employees, { lazy: true })
  @JoinTable()
  @TypeormLoader((type) => Cert, (employee: Employee) => employee.certIds)
  certs: Lazy<Cert[]>;

@ManyToMany((type) => User)
  @JoinTable()
  testers: User[];

@ManyToMany((type) => CashAccount, (cashAccount) => cashAccount.cashActionList)
    @JoinTable({
        name: 'cash_account_action_list_cash_action',
        joinColumns: [{ name: 'cashActionId', referencedColumnName: 'id' }],
        inverseJoinColumns: [{ name: 'cashAccountId', referencedColumnName: 'id' }],
    })
    cashAccountList: CashAccount[];

@ManyToMany(type => Handle)
    @JoinTable({
        name: "chat_handle_join",
        joinColumns: [{ name: "chat_id" }],
        inverseJoinColumns: [{ name: "handle_id" }]
    })
    participants: Handle[];

@ManyToOne(() => Beatmap, beatmap => beatmap.guestRequests, {
        nullable: false,
        eager: true,
    })
    @JoinTable()
    beatmap!: Beatmap;

@JoinTable()
    @ManyToMany(type => Coupon)
    coupons?: Coupon[] | null;

@ApiProperty({ type: type => LicenseScanResultItem, isArray: true })
  @OneToMany(type => LicenseScanResultItem, licenseScanResultItem => licenseScanResultItem.license, { nullable: true })
  @JoinTable()
  licenseScanResultItems: LicenseScanResultItem[];

@ManyToMany((type) => CashImportConfig, (cashImportConfig) => cashImportConfig.cashAccountList)
    @JoinTable({
        name: 'cash_account_import_config_list_cash_import_config',
        joinColumns: [{ name: 'cashAccountId', referencedColumnName: 'id' }],
        inverseJoinColumns: [{ name: 'cashImportConfigId', referencedColumnName: 'id' }],
    })
    importConfigList: CashImportConfig[];

@ManyToMany( () => Product, ( product ) => product.categories )
	@JoinTable( {
		name: 'product_category',
		joinColumns: [ { name: 'categoryId', referencedColumnName: 'id' } ],
		inverseJoinColumns: [ { name: 'productId', referencedColumnName: 'id' } ],
		schema: 'shop',
	} )
	products: Product[];

@ManyToMany((type) => CashAccount, (cashAccount) => cashAccount.cashFilterList, { cascade: [] })
    @JoinTable({
        name: 'cash_account_filter_list_cash_filter',
        joinColumns: [{ name: 'cashFilterId', referencedColumnName: 'id' }],
        inverseJoinColumns: [{ name: 'cashAccountId', referencedColumnName: 'id' }],
    })
    cashAccountList: CashAccount[];

@ManyToMany(type => Discipline, { eager: true })
  @JoinTable()
  discipline: Discipline[];

@ManyToMany(() => Site)
  @JoinTable()
  sites: Site[];

@ManyToMany(() => Photos, { cascade: true })
  @JoinTable()
  photos?: Photos[];

@ManyToMany(
    () => UserEntity,
    user => user.chatRooms,
  )
  @JoinTable()
  attendees: UserEntity[];