Styjun

I'm using mapped types to transform a data structure, which works as expected except when there is a recursive field.

Is there a way to prevent it from becoming type any?

type DataType<T extends Record<keyof T, Obj<any, any>>> = 
 [P in keyof T]: T[P]['data']


// I need to be able to pass in a Data generic
// to this object
class Obj<
 Data extends DataType<T>,
 T extends Record<keyof Data, Obj<any, any>>
> 
 constructor(public fields: T) 

 public data: Data


const recursive = new Obj(
 // With this field, the 'recursive' variable becomes type 'any'
 get query() 
 return recursive
 ,
 test: new Obj()
)

// Without recursive field it works as expected
const nonRecursive = new Obj( test: new Obj() )
nonRecursive.data.test // okay

Hmm, you're carrying around a lot of mutually referential generic types here, and without a use case and examples I admit I have almost no idea what's going on here and if this is really the best way to represent your data structure. I'd guess you could probably get away with a single type parameter like this:

class Obj<T>

 constructor(public fields: [K in keyof T]: Obj<T[K]> ) 
 
 public data!: T

But even if you do that you will still have the same issue, which gets exposed if you enable the stricter compiler options like --noImplicitAny or --strict. Then you will see that your definition of recursive gives you the following errors:

'recursive' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer.

and

'query' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions.

This is the intended behavior when the compiler cannot infer a type because it depends on itself in certain ways. The suggested way to deal with this is usually to give an explicit type annotation to one of the pieces to break the circularity. It's annoying because it forces you to redundantly write out typings to things that were previously inferred by the compiler, but I don't know if there's a good way to avoid that.

Here's one way of doing it with the types as you have them:

// explicit type
interface RecursiveObj extends Obj<
 DataType<
 readonly query: RecursiveObj; test: Obj<, >; 
 >, readonly query: RecursiveObj; test: Obj<, >; > 


const recursive = new Obj(
 // explicitly annotated return type
 get query(): RecursiveObj 
 return recursive
 ,
 test: new Obj()
); // okay now

And here's how I'd do it with the simplified Obj<T> type I listed above:

// explicit type
interface RecursiveData 
 readonly query: RecursiveData,
 test: 


const recursive = new Obj(
 // explicitly annotated return type
 get query(): Obj<RecursiveData> 
 return recursive
 ,
 test: new Obj()
); // okay now

Okay, hope that helps. Good luck!