TypeScript 循环/递归接口定义

Question

Base case

I'm having trouble defining a modular type system that suits my needs in a modular way. Here's a simple version of my problem :

I need two slightly different representations of pretty much the same types system : One for the frontend, one for the backend (I'll explain the difference later, now this is only for context). I'm trying to define a types system where I'm able to derive one from the other, as it seems theorically doable.

Here's how to understand the model :

• A User has multiple Team s.
• A Team has multiple Unit s.

That's all there is conceptually : (A)

type IUser = {
    username: string,
    teams: ITeam[],
};

type ITeam = {
    teamname: string,
    user: IUser ,
    units: IUnit[],
}

type IUnit = {
    unitname: string,
    team: ITeam ,
}

I need to be able to access each relation in both ways (both User -> Team , and Team -> User for example). From the User down to the Unit, and from the Unit up to the User.

Context

That works well to type what my frontend will play with. Now, here's what I need to represent in the backend : I'm using TypeORM, so each of these is an Entity and reality the code rather looks like this :

(B) ( this is also mostly for context, there's a playground stripped of any TypeORM logic lower)

import {Entity, Column, OneToMany, ManyToOne} from "typeorm";

@Entity()
class User extends BaseEntity {
    @Column()
    username: string,

    // A User has many Teams, loaded lazily
    @OneToMany(() => Team, (team) => team.user, {})
    teams: Promise<Team[]>,
};

@Entity()
class Team extends BaseEntity {
    @Column()
    teamname: string,

    // A Team is owned by one User, loaded eagerly
    @ManyToOne(() => User, (user) => user.teams, {
        eager: true,
    })
    user: User,

    // A Team has many Units, loaded lazily
    @OneToMany(() => Unit, (unit) => unit.team, {})
    units: Promise<Unit[]>,
}

@Entity()
class Unit extends BaseEntity {
    @Column()
    unitname: string,

    // A Unit is owned by one Team, loaded eagerly
    @ManyToOne(() => Team, (team) => team.units, {
        eager: true,
    })
    team: Team,
}

Now of course as the documentation of TypeORM tells us :

Eager relations can only be used on one side of the relationship, using eager: true on both sides of relationship is disallowed.

So I chose a direction in which all relations would load eagerly, and an other where they'd load lazily. I decided I'd load the descending way lazily (cause in my use case I won't need every Team of a User every time), and load the ascending way eagerly (cause I'll want to know the User of a Unit every time in my use case).

What I want

I want to verify that model (B) is just model (A) with some promisified fields.

---

Problem

Now I can't verify that model (B) has anything to do with model (A), because some of the properties the fields reference also have been promisified.

---

What I tried

You can follow along this TypeScript playground link, which strips this problems of the TypeORM context and focuses on the actual type definitions : Playground link

I've put the two models I described earlier, as well as my current reasoning on how I could use one to derive from the other. But now I'm stuck : You can read until the end of the playground to understand that I'd need some kind of recursion that I don't know how to express.

Answer 1

My approach for fixing this is to make sure that the frontend and backend versions both implement some shared interface. For this shared interface, I say that a value can either be a promise or a resolved value by creating a utility type MaybePromise<T> :

type MaybePromise<T> = T | Promise<T>;

Using this utility type, I redefine the I interfaces to be the shared base, which might or might not have promises.

type IUser = {
    username: string,
    teams: MaybePromise<ITeam[]>,
};

type ITeam = {
    teamname: string,
    user: MaybePromise<IUser>,
    units: MaybePromise<IUnit[]>,
}

type IUnit = {
    unitname: string,
    team: MaybePromise<ITeam>,
}

If we want to get back the original non-promised interfaces, we can do that using another utility type which will replace these maybe promises with their resolved values.

type UnpromisifyFields<T> = {
    [key in keyof T]: T[key] extends MaybePromise<infer U> ? UnpromisifyFields<U> : T[key]
}

Making this recursive means that the resolved types aren't particularly readable, but they do seem to be correct.

type PureUser = UnpromisifyFields<IUser>
// becomes { username: string; teams: UnpromisifyFields<ITeam>[]; }

type PureTeam = UnpromisifyFields<ITeam>

type PureUnit = UnpromisifyFields<IUnit>

Our backend classes are able to implement the base MaybePromise interfaces:

class User implements IUser {    
    username!: string;
    teams!: Promise<Team[]>;
};

class Team implements ITeam {
    teamname!: string;
    user!: User;
    units!: Promise<Unit[]>;
}

class Unit implements IUnit {
    unitname!: string;
    team!: Team;
}

I think this solves most of your issues.