Generics with constrained parameters

[dielsalder]

Here's a minimal example of some existing ts types that I want to convert to typebox schemas:

// typescript types
type WithName = {name: string}
type WithId<T extends WithName> = WithName & {id: string}

The doc say to use T extends TSchema for generic schemas, but there is no advice on how to constrain the parameter schemas to already-existing schemas. I have tried some variations of this without success:

// Argument of type 'T' is not assignable to parameter of type 'TSchema[]'.
// Type '{ name: string; }' is missing the following properties from type 'TSchema[]': length, pop, push, concat, and 29
// more.ts(2345)

const WithName = Type.Object({ name: Type.String() });
const WithId = <T extends Static<typeof WithName>>(T: T) =>
  Type.Intersect(
    T,
    Type.Object({
      id: Type.String(),
    })
  );

// Argument of type 'T' is not assignable to parameter of type 'TSchema[]'.
// Type 'TObject<{ name: TString; }>' is missing the following properties from type 'TSchema[]': length, pop, push, concat, and 29 // more.ts(2345)

const WithName = Type.Object({ name: Type.String() });
const WithId = <T extends typeof WithName>(T: T) =>
  Type.Intersect(
    T,
    Type.Object({
      id: Type.String(),
    })
  );

Is it possible to do this in typebox? Would appreciate any guidance!

[sinclairzx81]

@dielsalder Hi,

The Type.Intersect type constituents need to be wrapped in a []. You can try the following.

TypeScript Link Here

import { Type } from '@sinclair/typebox'

const WithName = Type.Object({ name: Type.String() });
const WithId = <T extends typeof WithName>(schema: T) => Type.Intersect([
  schema,
  Type.Object({
    id: Type.String(),
  })
]);


// ok, object has 'name' property
const A = WithId(Type.Object({ name: Type.String()  })) // ok, has name

// ok, object has 'name' property + 'role' property
const B = WithId(Type.Object({ name: Type.String(), role: Type.String()  })) 

// error: object does not have 'name' property
const C = WithId(Type.Object({ role: Type.String() }))

Note: The above will work for Object types as the underlying schematics structurally extend, however covariance mileage will vary depending on kinds of schema used to constrain the generic argument (as some json schematics may not structurally extend one another in ways TS can reason about). There is work being done to improve this in later revisions.

So, while the above works, it's usually more common to constrain to TObject for this kind of Intersection. The following will also work (where the generic type can accept any TObject type irrespective of properties)

import { Type, TObject } from '@sinclair/typebox'

const WithId = <T extends TObject>(schema: T) => Type.Intersect([
  schema,
  Type.Object({
    id: Type.String(),
  })
]);

Hope this helps
S

[dielsalder]

Makes sense, thanks for your reply! It helped me figure out the actual issue in my code. Here's a minimal example:

const WithId = <T extends TObject>(schema: T) =>
  Type.Intersect([
    schema,
    Type.Object({
      id: Type.String(),
    }),
  ]);

const A = Type.Object({ a: Type.String() });
const B = Type.Object({ b: Type.String() });
const Intersection = Type.Intersect([A, B]);
const IntersectionWithId = WithId(Intersection);

// ts 2345: Property 'properties' is missing in type 'TIntersect<[TObject<{ a: TString; }>, TObject<{ b: TString; }>]>' but required in type 'TObject<TProperties>'.

The issue looks to be that Intersection doesn't actually extend TObject. The error goes away if I wrap Intersection in Type.Object, but idk if that will work as intended.

Any advice here?

[sinclairzx81]

@dielsalder Hiya,

You can add an additional TIntersect constraint to the WithId function.

import { Type, TObject, TIntersect } from '@sinclair/typebox'

const WithId = <T extends TObject | TIntersect>(schema: T) =>
  Type.Intersect([
    schema,
    Type.Object({
      id: Type.String(),
    }),
  ]);

Unfortunately, even though the Intersect type is structurally an Object type in this case, the TIntersect json schematics do not structurally extend TObject (even though in TypeScript this would be permissible). Because the json schema structures are different, you must specify a TIntersect in the generic constraint.

[dielsalder]

That worked. Much thanks!