Generics, computing the inverse of Static<T>

[00dani]

Hi! I'm trying to integrate TypeBox into an existing TypeScript codebase, as a much more robust alternative to value is T predicate functions. But I'm having trouble getting things to type-check properly, because I want to maintain the existing generic types as much as possible.

The TypeBox docs say to use T extends TSchema for your generic type parameters, and the Workbench produces code that does this. But if my regular TypeScript type looks like this:

export interface EventDTOBase<TType extends string, TData> {
  source_type: TType;
  source_key: string;
  source_subkey: string | null;
  data: TData;
}

Then TypeBox's workbench will turn that into:

export type EventDTOBase<TType extends TSchema, TData extends TSchema> = Static<
  ReturnType<typeof EventDTOBase<TType, TData>>
>
export const EventDTOBase = <TType extends TSchema, TData extends TSchema>(
  TType: TType,
  TData: TData
) =>
  Type.Object({
    source_type: TType,
    source_key: Type.String(),
    source_subkey: Type.Union([Type.String(), Type.Null()]),
    data: TData
  })

Which "forgets" the extends string condition on TType, and also requires references to the type to be written something like EventDTOBase<TString, TData> rather than EventDTOBase<string, Data>. Since I'm not actually going to be serialising or validating many of the types in the system, having to use TypeBox's types for all of them isn't ideal.

So I've been experimenting with this approach, which expects regular TypeScript types as the type-level parameters and then TypeBox schemas as the value-level parameters:

/** Static<T>, except that it works on generics too. This part works fine. :) */
export type Unboxed<T> =
  T extends TSchema ? Static<T>
  : T extends (...args: unknown[]) => TSchema ? Static<ReturnType<T>>
  : never;
/** Theoretically the inverse of Static<T>, turning a regular TypeScript type into a static schema type matching up with it. This part does not work. */
export type Boxed<T> = T extends Static<infer U extends TSchema> ? U : never;

export type EventDTOBase<TType extends string, TData> = Unboxed<typeof EventDTOBaseSchema<TType, TData>>;
export const EventDTOBaseSchema<TType extends string, TData> = (
  TType: Boxed<TType>,
  TData: Boxed<TData>
) =>
  Type.Object({
    source_type: TType,
    source_key: Type.String(),
    source_subkey: Type.Union([Type.String(), Type.Null()]),
    data: TData
  });

However TypeScript doesn't seem to be quite clever enough to infer the schema type from Boxed<T>, which isn't surprising since Static<T> is basically just T['static']. I also tried just making the function arguments (TType: TSchema, TData: TSchema), but the inference still struggled and it couldn't type the return value correctly even if that worked.

So, is there a way to derive schema types from regular TypeScript types in-language? I don't need to actually generate the runtime schema, and I'm aware TypeScript wouldn't let you do that anyway due to type erasure - I just need a way to write "given type T, give me type U such that Static<U> = T" at the type level.

Or, possibly, a different approach entirely to writing generic types compatible with TypeBox. Is there a technique I'm missing, maybe?

[castarco]

So, is there a way to derive schema types from regular TypeScript types in-language?

I'd say "yes"... with a lot of reservations. It probably requires "heavy type machinery" to cover for tons of edge cases.

The problem here is not just that we'd have to define a very complex type, or a collection of them (because that could be done once, and reused thousands of times after that).

The real problems I foresee are:

• In best case scenario: such type machinery would heavily impact type inference and type checking performance.
• In worst case scenario: there would be so much nesting that the compiler would refuse to continue processing that type, so nothing gained, even after paying with much increased type inference/checking times.