typebox VS typia

The documentation can be found here.

So far I like the commonly used approach in the Typescript community best:

1. Create your Schema using https://zod.dev or https://github.com/sinclairzx81/typebox

2. Generate your Types from the schema. It's very simple to create partial or composite types, e.g. UpdateModel, InsertModels, Arrays of them, etc.

3. Most modern Frameworks have first class support for validation, like is a great example Fastify (with typebox). Just reuse your schema definition.

That is very easy, obvious and effective.

There's a ton of schema validators out there and most devs have their personal favorite. Mine was zod and is now typebox + ajv.

If you're willing to document your API with an OpenAPI schema, then it should be possible to generate TypeScript types based on the OpenAPI schema with something like openapi-typescript. Also, Typebox can generate JSON schemas, maybe it can be used to generate something that the front-end can also use?

Well, I do provide extensibility for those bullet points you've listed to varying degrees (both schema and type representation), as well as offering a reference implementation for expressing a entirely different schema specification under the type system (specifically RFC8927 / JSON Type Definition). Reference implementation here. As for JSDoc, It's supported in code hints.

In setting out to build this service, we wanted to use gRPC for its APIs. We’ve been reaching for REST when building APIs so far, primarily out of necessity, i.e., our public APIs needed auto-generated client SDKs and docs for developers working with them. We built those APIs with Fastify and Typebox but felt burned by a code-first approach to generating an OpenAPI spec. I’ll spare you the details and save that experience/learning for another article. Suffice it to say we love gRPC’s schema-first approach. This blog post summarizes our feelings well

Therefore, I've implemented the Protocol Buffer features for two months, and introduce you. From now on, you can easily use Protocol Buffer features in typia, with pure TypeScript type. You no more need to define extra schema even including *.proto file. typia will do everything for you. It will analyze your TypeScript type, and generate Protocol Buffer schema and de/serializers automatically.

I've written some articles introducing my TypeScript runtime validator library typia in here dev.to community. In these previous articles, I had often explained that typia boosts up validation spped through AoT (Ahead of Time) compliation, and it is maximum 20,000x faster than class-validator.

typia: https://github.com/samchon/typia

If you see actual Mockup Simulator code, then you may exactly understand what it is. Yes, the Mockup Simulator, it's just an internal function returning random data with same type of API interface. For reference, mockup data generation is being done by typia.random() function, which can analyze TypeScript type and generate optimal random generation code in the compliation level.

typia is a super-easy and fast runtime validator library, which needs TypeScript type only. It does not need extra schema definition like ajv or class-validator. It can analyze TypeScript by itself, and generates optmial validation code for each type.

Guide Documents: https://typia.io

We already do some black magic wizardry with decorators, why not do this too? If it's a flop, at least it will have the company of namespace, enum and interface to hang out with. The typia library already does this and the performance results are a bit staggering, it doesn't support TypeScript 5.0 yet and requires 3rd party tools to shim a modification into the tsc command but it feels like something that should be a part of TypeScript right now.