With 1.0, as a fn arg, how can I accept only Schemas that validate a specific type?

[holvi-sebastian]

Heya!

In 0.34, I used to be able to write functions like:

function acceptSchemaFor<T>(schema: TSchema & { static: T }) {
   // do something with schema
}

This is useful in case I wanted to restrict the fn to accept only Schemas whose Statics match a given type T.

acceptSchemaFor<{ foo: string }>( ... ) // Accept only schemas that contain 'foo'.

Not sure how to do this in 1.0 though, because there's no static prop any more...?

Is there an equivalent in 1.0?

[martaver]

@sinclairzx81 what do you think would be the way to approach this? Should I try to build an inverse of StaticType?

[sinclairzx81]

@holvi-sebastian @martaver Hi, just a quick update here.

I have been experimenting around with a possible ReverseStatic<T> type that accepts a TypeScript type, and returns a TypeBox TSchema type. The implementation is "mostly" complete, but does need extra work to support readonly and optional property inference from objects.

I have checked in a prototype into the TB repo for now. I do think there would be value in having an inverse static type, but do note there are some quirks with respect to typescript evaluation ordering, as well as the inability to infer Intersect due to TS intersections being opaque ... but everything else should be feasible (at least to the point of being somewhat useful for constraining TB types via TS types)

Links and Info below

ReverseStatic<T>

Prototype | Example

function acceptSchemaFor<T>(value: ReverseStatic<T>) {} // <-- here

// string
acceptSchemaFor<string>(Type.String())

// object
acceptSchemaFor<{ foo: string, bar: number }>(Type.Object({
  foo: Type.String(),
  bar: Type.Number()
}))


// tuple
acceptSchemaFor<[1, 2, 3]>(Type.Tuple([
  Type.Literal(1),
  Type.Literal(2),
  Type.Literal(3)
]))

// union
acceptSchemaFor<1 | 2>(Type.Union([
  Type.Literal(1), Type.Literal(2)
]))

// array | union - note: dependent on TS type ordering
acceptSchemaFor<number[] | 1>(Type.Union([
  Type.Literal(1), 
  Type.Array(Type.Number()), 
]))

// script | complex - note: dependent on TS type ordering
acceptSchemaFor<{ 
  x: null | [ 1, 2, 3 ]
  y: { name: string },
  z: (string | number)[]  
}>(Type.Script(`{ 
  x: null | [ 1, 2, 3 ]
  y: { name: string },
  z: (string | number)[]  
}`))

[holvi-sebastian]

Hah! I was actually just playing with a similar concept myself and was about to suggest it to you!

Here was mine in this TS Playground...

Let me have a play around with this tomorrow and I'll report back!

[martaver]

Hm, one thing that occurs to me is that my goal is not necessarily to 'reverse' that logic of Static, but to create a type that is the set of all schemas that would produce a Static that satisfies T.

So in your ReverseStatic example, acceptSchema<{ foo: string }> results in requiring the exact schema TObject<{ foo: TString }>...

Whereas in my example, acceptSchema<{ foo: string }> would accept TObject<{ foo: TString }> | TUnion<TObject<{ foo: TString }>[]> | TIntersect<TObject<{ foo: TString }>[]> | Base<TObject<{ foo: TString }>> etc. so as to allow all arbitrary schemas whose Static would result in T or narrower.

[martaver]

Err @sinclairzx81 btw @martaver and @holvi-sebastian are both me, just different machines. Probably seems schizophrenic.

[holvi-sebastian]

Actually, maybe both should exist. Your approach makes more sense where the schema is being used as a guard for a function argument and the case is contravariant.