Proposal: add dynamic types from TypeScript types (like parse<type>(data))

[LBF38]

Hi, I would like to submit a proposal for enhancing the valibot DX and seamlessly integrate with TypeScript types.

For now, the valibot syntax relies on functions and rewriting all our types as const variables or schemas that then are used to validate any input/data to be safely typed both statically and dynamically.

Here is the current syntax so far (a very simple example):

// current valibot syntax
const schema = object({
	version: string(),
});
const data: unknown = "{ version: '1.18.2' }";

const result = safeParse(schema, data);
if (!result.success) {
	console.error(result.issues);
	throw new Error("Invalid data");
}
console.log(result.output.version);

As we can see, we have to shift all our types syntax to a variable with functions from valibot in order to have correct validation and everything it has to offer.

Therefore, here is my proposal on how to enhance this. It would be a dream to have this directly inside TypeScript (in some manner) and would resolve a lot of issues.
Here is the same code as above but with a TypeScript interface:

// proposal for new one

interface schema {  // This could be a `type` or any type from TypeScript.
	version: string;
}

const data: unknown = "{ version: '1.18.2' }";

const result = safeParse<schema>(data); // the runtime type of the data is inferred from the schema type.

if (!result.success) {
	console.error(result.issues);
	throw new Error("Invalid data"); // or return inside a function. Do something to not access the below code.
}
console.log(result.output.version);

As you can see, the result should be the same as the current valibot syntax. However, it allows for current codebases not using valibot to seamlessly switch to it by validating types dynamically as it can reuse the types it already has rather than making a huge refactoring and switching to variables schemas.

I don't know the details of its implementation. And I'll be happy to hear your thoughts on that proposal !

What do you think about that ?
Thanks

[fabian-hiller]

This is technically possible to implement. Typia is an example for this. Do you also have an idea how coerce, transform and the pipeline feature can be realized with this API design?

[LBF38]

I never heard about Typia, thank you for mentioning it !
For reference, I put the link to the repo here: https://github.com/samchon/typia

[sillvva]

https://github.com/decs/typeschema has links to various validation libraries. I like Valibot, because it's light-weight, fast, and has useful, extensible pipe-based validators.

[LBF38]

I like it too. I think that Valibot is simple to use. However, I found it more verbose than simply defining types/interfaces/... and passing them to a parse function on an unknown json for example.

@fabian-hiller how would you implement it ?

[fabian-hiller]

Probably with a TypeScript or Vite plugin. I see the problem more in the limited functionality or the API design. TypeScript functions like Valibot are very flexible and type-safe, which makes typos almost impossible.

[LBF38]

I see, as it would need to access the compiler for adding types in the runtime.
I agree that Valibot functions are flexible and type-safe, however it really feels like a DSL, and misses some features from TypeScript like the builtin documentation of types/interfaces/classes/... while adding more features too, like validating common schemas (email, etc).