effect resolver

[titouancreach]

Hello  👋

With @effect/schema, we have the ability to define a Schema that encode/decode to another type.

See this example:

const MySchema = S.Struct({
  createdAt: S.DateFromString
})

This is represented as Schema<A, I> where A is { readonly createdAt: Date } and I is { readonly createdAt: string }.

Currently the effect-ts resolver cannot exploit its full potential, because the same type A is used everywhere, example:

const form = useForm({
  resolver: effectTsResolver(MySchema);
  defaultValues: {
      createdAt: ""
//                ^  Type 'string' is not assignable to type 'Date'.ts(2322)
  }
})  

So I've looked at the source and we have a notion of TTransformedValue. It's not very documented but it looks that this is the type after they are transformed by the validator.

So in this example, TFieldValues would be { createdAt: string } and the TTransformedValue would be { createdAt: Date }.

Si I tweaked the effect resolver a little bit, and at the end I got the correct type (and correct runtime as well), but from the user side, it's far from perfect :

const MySchema = S.Struct({
  createdAt: S.DateFromString
})

type MySchemaFrom = S.Schema.Encoded<typeof MySchema>; // { createdAt: string }
type MySchemaTo = S.Schema.Type<typeof MySchema>;  // { createdAt: Date }

const form = useForm<MySchemaFrom, any, MySchemaTo>({ 
  resolver: effectTsResolver(MySchema);
  defaultValues: {
      createdAt: ""
//                ^  works
  }
})

It's far from perfect because:

• TTransformedValue can potentially be inferred, since our schema is of type Schema<A, I> (ie: Schema<TTransformedValues, TFieldValues>
• It required to pass the TContext parameter (any) here

So before submitting a pull request, we want to know if:

• is it possible to infer TTransformedValue from a resolver, and if so, how
• if it's impossible, can we swap TContext and TTransformedValue, so, we don't have to pass any explicitely.

I think this would be benefit, not only for the effect resolver, but for all the resolver that are able to transform types.

Thanks very much for reading this

[stevebluck]

I think the handleSubmit should receive both the original and decoded data for SSR use cases.

Imagine this form data gets sent to the server where it must also validate the data. It would need the original values so you can decode using the same schema on the client and server.

[EwelinaKi]

const MySchema = S.Struct({ createdAt: S.ValidDateFromSelf })
do the job for me