在TypeScript接口密钥迭代中使用条件类型

Question

Hi have 2 interfaces and a type

interface A { k1: string k2: string }

interface B { k3: string k4: A }

type Error = { key:string, value:string}

I have developed a declaration that creates an interface with all the keys of a given interface and the type = Error[]

type AutoErrors<P> = { [K in keyof P]-?: Error[] }

That works well since AutoErrors<A> gives { k1: Error[] k2: Error[] }

But now I would like it to be recursive, ie , if the parameter type key is not of type string I would like its type to be AutoErrors<T>

For example AutoErrors<B> should be { k3: Error[], k4: AutoErrors<A> }

I have tried

type AutoErrors<X> = { [K in keyof X]-?: X[K] extends string ? Error[] : AutoErrors<X[K]> } type AutoErrors<X> = { [K in keyof X]-?: X[K] extends string ? Error[] : AutoErrors<X[K]> } but it is not working well , as if the test X[K] extends string is not well interpreted

Answer 1

You can use an approach similar to the one for DeepReadOnly

export type primitive = string | number | boolean | undefined | null
export type DeepError<T> = 
    T extends (infer U)[] ? Array<DeepErrorObject<U>> :
    T extends primitive ? Error[] : DeepErrorObject<T>;

export type DeepErrorObject<T> = {
readonly [P in keyof T]: DeepError<T[P]>
}
// sample usage
interface A {
    k1: string
    k2: string
} 
interface B {
    k3: string
    k4: A
    k4Arr: B[]
}
type Error = { 
    key:string, 
    message:string
}

type ErrorA = DeepError<B>
let d: ErrorA;
d.k4Arr[0].k3; // Error[]

Answer 2

The code as posted in your question works in the Playground , so I suspected that something else was going on. As it turns out, the issue had to do with optional properties, such as

type UhOh = AutoErrors<{ a?: string }>; // becomes {a: string}, not good

The original AutoErrors<> definition didn't work in that case, because string | undefined string | undefined does not extend string . The fix for that, as you know, is to check for string | undefined string | undefined instead of just string :

type AutoErrors<X> = {
  [K in keyof X]-?: X[K] extends string | undefined ?
  Error[] : AutoErrors<X[K]>
}

which works:

type Okay = AutoErrors<{ a?: string }>; // becomes {a: Error[]}, as expected

Glad you found out what was going on.