TYPEORM/Postgres: one-directional foreign key - typeorm

Question

I have an entity that represents a wallet transaction. This Entity needs to be generic so I have it declared in a package and then reuse it in different services. I will explain what I am trying to do on an example.
Each service that uses the wallet transaction base class will have tables, that refer to it. For instance, I have a shop service, that has a list of transactions and table of sales and a table of returns. Another service, let's call it payments, will have the same wallet transaction table in its own database but the tables that will refer to it will be different - for instance deposits and payouts.
The common thing here is that in the wallet transaction table, there is a column with an id that references something in a separate table. Explained with code:
Generic Transaction table
export abstract class TransactionEntity<TransactionType> {
#PrimaryGeneratedColumn('identity', {
type: 'bigint',
generatedIdentity: 'ALWAYS',
primaryKeyConstraintName: PK_TRANSACTION_ID,
})
id!: number;
#Unique(UQ_WALLET_TRANSACTION_ID, ['walletTransactionId'])
#Column({ type: 'bigint', nullable: true })
walletTransactionId!: number;
#Column('text')
userId!: string;
#Column('bigint')
walletId!: number;
#Column({ type: 'text', nullable: true })
currency!: string;
#Column({
type: 'decimal',
precision: 24,
scale: 6,
})
amount!: number;
#Column('text')
status!: ServiceTransactionStatus;
#Column('text')
transactionType!: TransactionType;
#Column('bigint')
referenceId!: number; // reference to local tables with relevant information
}
In service that needs to reuse the transaction
Deposit = 'deposit',
Refund = 'refund',
}
#Entity()
export class WalletTransaction extends TransactionEntity<WalletTransactionType> {}
Specific table that needs to refer to the transaction table
export class Deposit {
#PrimaryGeneratedColumn('identity', {
type: 'bigint',
generatedIdentity: 'ALWAYS',
primaryKeyConstraintName: 'pk_deposit_id',
})
id!: number;
#Index('idx_deposit_user_id')
#Column('text')
userId!: string;
#Column('text')
someData!: string;
...
#OneToMany(() => WalletTransaction, (walletTransaction) => walletTransaction.referenceId)
#JoinColumn({ foreignKeyConstraintName: 'fk_deposit_wallet_transaction' })
walletTransactions!: Relation<WalletTransaction[]>;
}
The problem I have is that it does not seem to be possible to do a one way OneToMany in TypeORM so no migration gets generated and I don't get the reference_id column.
As far as I have found, TypeORM does not allow to have a single-directional relation (i.e. you can't have OneToMany refering to a table without the corresponding ManyToOne in the original table.
I would like to be able for multiple tables to have a reference to the common transaction table and I would like to have a foreign key that ensures each record in for instance the deposit table has a corresponding record in the WalletTransaction table. I know how to do it in postgres if I manually create a migration to set this up
I have tried to define everything as above but TypeORM does not then pick up on the connection between the reference_id and a corresponding table.
I would be OK with adding a column to the wallet_transaction table to refer to a specific table to say where the foreign key has the ManyToOne target (deposit table, payout table). Maybe there is some way to use compound keys
I have tried to google around but I have found only a few articles that say that one direction connection like this is not possible in Typeorm. They were all older date but the TypeORM documentation basically assumes that the only way to connect 2 tables is having both way OtM/MtO specified.