user.model.ts

import { Entity, Column, OneToMany, BeforeInsert, OneToOne, JoinColumn } from "typeorm";
import { IsString, IsEmail, IsMobilePhone, IsJWT } from "class-validator";
import * as bc from "bcrypt";
import { BaseEntity } from "../base/BaseEntity"
import { UserLogin } from "./login.model";
import { Image } from "../common/image.model";
import { Wallet } from "../payment/wallet.model";
import { Restaurant } from "../restaurant/restaurant.model";
import { PaymentMethod } from "../payment/method.model";
import { Token } from "./token.model";
import { Coupon } from "../coupon/coupon.model";
import { UserConnection } from "./connection.model";
import { Order } from "../order/order.model";
import { Review } from "../restaurant/review.model";
import { Notification } from "./notification.model";
import { Address } from "../common/address.model";
import { Transaction } from "../payment/transaction.model"

export enum RegisteredFrom {
    api = "API",
    site = "SITE",
    mobile = "MOBILE_APP",
    customer = "CUSTOMER_APP"
}

export enum Roles { 
    admin = "ROLE_ADMIN",
    restaurant = "ROLE_RESTAURANT",
    user = "ROLE_USER",
    driver = "ROLE_DRIVER"
}

const genSalt = () => bc.genSalt(parseInt(process.env.BCRYPT_SALT_ROUNDS as string));

@Entity()
export class User extends BaseEntity {

    @Column()
    @IsString()
    public name!: string;

    @Column()
    @IsString()
    public surname!: string;

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

    @Column()
    public password!: string;

    @OneToMany(() => Address, address => address.user, { nullable: true })
    public addresses!: Address[];

    @Column({unique: true})
    @IsMobilePhone()
    public phoneNumber!: string;
    
    @OneToMany(() => Token, token => token.user, { cascade: true, onDelete: "CASCADE" })
    public tokens!: Token[];

    @OneToMany(() => UserLogin, ul => ul.id, { nullable: true })
    public previousLogins!: UserLogin[];
 
    @OneToOne(() => Image, { nullable: true })
    public profileImage!: Image;

    @Column({
        type: "enum",
        enum: RegisteredFrom,
        default: RegisteredFrom.site
    })
    public registeredFrom!: RegisteredFrom;
    
    @OneToOne(() => Wallet, wallet => wallet.id, { nullable: true, onUpdate: 'CASCADE' })
    @JoinColumn()
    public wallet!: Wallet;

    @OneToMany(() => Restaurant, res => res.id, { nullable: true })
    public favorites!: Restaurant[];

    @Column({
        default: 0
    })
    public trustLevel!: number;

    @Column({
        type: 'enum',
        enum: Roles,
        default: Roles.user
    })
    public roles!: Roles;

    @OneToMany(() => Notification, nt => nt.id)
    public notifications!: Notification[];

    @OneToMany(() => PaymentMethod, pm => pm.user, { nullable: true, cascade: true })
    public paymentMethods!: PaymentMethod[];

    @OneToMany(() => Coupon, c => c.id)
    public usedCoupons!: Coupon[];

    @OneToMany(() => UserConnection, connection => connection.user)
    public userConnections!: UserConnection[];

    @OneToMany(() => Order, order => order.user, { onDelete: "CASCADE" })
    public orders!: Order[];

    @OneToMany(() => Review, r => r.user, { onDelete: "CASCADE" })
    public reviews!: Review[];

    @OneToMany(() => Transaction, t => t.user, { cascade: true, nullable: true })
    public transactions!: Transaction[];

    @BeforeInsert()
    public async hashPassword() {
        this.password = await bc.hash(this.password, await genSalt())
    }

    public get flat() {
        return {
            id: this.id,
            name: this.name,
            surname: this.surname,
            email: this.email,
            phoneNumber: this.phoneNumber,
            roles: this.roles,
            profileImage: this.profileImage ? this.profileImage : null,
            walletBalance: this.wallet?.balance
        }
    }

}

user.subscriber.ts

import {EventSubscriber, EntitySubscriberInterface, InsertEvent} from "typeorm";
import { Wallet } from "../entity/payment/wallet.model";
import { User } from "../entity/user/user.model";

@EventSubscriber()
export class UserSubscriber implements EntitySubscriberInterface<any> {
    listenTo() {
        return User;
    }

    afterInsert(e: InsertEvent<User>) {
        const wallet = new Wallet();
        wallet.user = e.entity;
        e.entity.wallet = wallet;
        
        try {
            e.manager.save(e.entity.wallet);
        } catch(err) {
            console.log(err);
        }
    }
}

wallet.enttiy.ts

import { Entity, Column, OneToMany, OneToOne } from "typeorm"
import { BaseEntity } from "../base/BaseEntity"
import { User } from "../user/user.model";
import { Transaction } from "./transaction.model";

@Entity()
export class Wallet extends BaseEntity {

    @Column({
        default: 0
    })
    public balance!: number;

    @OneToMany(() => Transaction, tr => tr.wallet, { nullable: true })
    public transactions!: Transaction[];

    @OneToOne(() => User, user => user.id)
    public user!: User;
    
}