TypeScript: interface polymorphism issue

Question

I have a base Account interface:

interface Account {
  id: number;
  email: string;
  password: string;
  type: AccountType;
}

where AccountType:

enum AccountType {
  Foo = 'foo',
  Bar = 'bar'
}

and two account subtypes (FooAccount and BarAccount) that extend the Account interface:

interface FooAccount extends Account {
  foo: Foo;
}

interface BarAccount extends Account {
  bar: Bar;
}

Account is an aggregate that holds basic account info and, depending on the type, owns a Foo or a Bar object.

Actions on these objects, can only be performed by their owners (the account).

I have defined an AccountRepository:

export interface AccountRepository {
  findById(accountId: number): Account;
}

where the findById(accountId: number) returns an Account, but this account could be any FooAccount or BarAccount.

I want to use this findById function before performing any action on a Foo or Bar. For example, let's say I want to update an account's Foo:

would use findById(accountId: number) to retrieve the account
check the AccountType of the account, in this case account.type === AccountType.Foo
if the AccountType check is correct, then would access account.foo.id and use that fooId to perform the desired update

The problem here is, that this last point is failing: as findById(accountId: number): Account returns an Account and there is no foo: Foo property defined in its interface.

I have also tried the following, but cannot be done either:

const fooAccount: FooAccount = findById(accountId);

because the function returns an Account.

I am trying to figure out how can this be achieved, what am I missing out? Is there anything I could be doing wrong?

Titian Cernicova-Dragomir · Accepted Answer · 2019-02-09 16:33:44Z

5

The best solution is probably to use a discriminated union.

export class Bar { public idBar: number; }
class Foo { public idFoo: number; }
interface AccountCommon {
  id: number;
  email: string;
  password: string;
}

enum AccountType {
  Foo = 'foo',
  Bar = 'bar'
}

interface FooAccount extends AccountCommon {
  type: AccountType.Foo; // type can only be Foo
  foo: Foo;
}
interface BarAccount extends AccountCommon {
  type: AccountType.Bar; // type can only be Bar
  bar: Bar;
}
// The discriminated union
type Account = BarAccount | FooAccount //type is common so type can be either Foo or Bar

export interface AccountRepository {
  findById(accountId: number): Account;
}

let r: AccountRepository;

let a = r.findById(0);
if (a.type === AccountType.Bar) { // type guard
  a.bar.idBar // a is now BarAccount
} else {
  a.foo.idFoo // a is now FooAccount
}

answered Feb 9, 2019 at 16:33

Titian Cernicova-Dragomir

253k37 gold badges464 silver badges394 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Jose Carlos Coutinho Over a year ago

Link to the docs: typescriptlang.org/docs/handbook/…

Artem A Over a year ago

this is not a polymorphism at all

charliebrownie · Accepted Answer · 2019-02-16 15:32:30Z

-3

Solved this using Type Assertion, by just adding as FooAccount like this:

const fooAccount: FooAccount = findById(accountId) as FooAccount;

There's no need to modify the existing design to achieve it.

Basically, the assertion from type S to T succeeds if either S is a subtype of T or T is a subtype of S.

More info: https://basarat.gitbooks.io/typescript/docs/types/type-assertion.html

answered Feb 16, 2019 at 15:32

charliebrownie

6,22711 gold badges40 silver badges56 bronze badges

Collectives™ on Stack Overflow

TypeScript: interface polymorphism issue

2 Answers 2

2 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related