trpc-openapi VS zod

tRPC does not natively export OpenAPI documents, but the trpc-openapi package adds this functionality. We'll start this tutorial by adding trpc-openapi to a project, and then we'll add a script to generate an OpenAPI schema and save it as a file.

While trpc-openapi originally was used to expose REST endpoints of the tRPC router, we will use it to generate an OpenAPI specification for our API.

Sure it can, you can use https://github.com/prosepilot/trpc-openapi

You either have to go with react native or use https://github.com/jlalmes/trpc-openapi to generate rest endpoint using trpc. lol. Not sure how good the trpc-openapi package is though. Read somewhere it was missing stuff

As for exposing the API externally, neither (can) limit this but SvelteKit's API is generally considered to be an internal implementation detail that you don't use directly since it might change between versions. If you want to expose an API you should choose tRPC, probably alongside the OpenAPI plugin or something similar.

In essence, features of the language made for static type checking at compilation are possibly being left favour of tools that act like a superset of the language that provide the static build type checking and offer runtime type checking too. An example I recently saw was the trpc-openapi package which uses Zod for creating the types of the schema for the http request and responses, it takes a zod schema as that is what it can use when compiled to JavaScript to generate the types for the openapi file at runtime, there's scarcely a type or interface in sight when using it but you have full type safety.

Take a look at https://github.com/jlalmes/trpc-openapi which will give you a rest endpoint based on your trpc router. Ymmv in reality but basically this should give you some confidence that your trpc router can be called from another client (not just next).

Ok thanks, I did find a good example here https://github.com/jlalmes/trpc-openapi/blob/master/examples/with-nextjs/src/server/router.ts

There is an OpenAPI Extension for tRPC that can be used to create a more REST-like API from your procedures, and that in turn can be used for auto-generating documentation. But if my app needed to offer third-party API access, I would likely reach for GraphQL again.

tRPC is nice because you have type safety the whole way down. Someone has made a tRPC OpenaAPI for exposing tRPC procedures externally in the OpenAPI format https://github.com/jlalmes/trpc-openapi

[Zod Documentation](https://zod.dev/) [Zod Error Handling](https://zod.dev/ERROR_HANDLING?id=error-handling-in-zod) [React-Hook-Form Documentation](https://react-hook-form.com/get-started) [Hookform Resolvers](https://www.npmjs.com/package/@hookform/resolvers)

This is a very fair comment, and you seem open to understanding why types are useful.

"problems that are due to typing" is a very difficult thing to unpack because types can mean _so_ many things.

Static types are absolutely useless (and, really, a net negative) if you're not using them well.

Types don't help if you don't spend the time modeling with the type system. You can use the type system to your advantage to prevent invalid states from being represented _at all_.

As an example, consider a music player that keeps track of the current song and the current position in the song.

If you model this naively you might do something like: https://gist.github.com/shepherdjerred/d0f57c99bfd69cf9eada4...

In the example above you _are_ using types. It might not be obvious that some of these issues can be solved with stronger types, that is, you might say that "You rarely see problems that are due to typing".

Here's an example where the type system can give you a lot more safety: https://gist.github.com/shepherdjerred/0976bc9d86f0a19a75757...

You'll notice that this kind of safety is pretty limited. If you're going to write a music app, you'll probably need API calls, local storage, URL routes, etc.

TypeScript's typechecking ends at the "boundaries" of the type system, e.g. it cannot automatically typecheck your fetch or localStorage calls return the correct types. If you're casting, you're bypassing the type systems and making it worthless. Runtime type checking libraries like Zod [0] can take care of this for you and are able to typecheck at the boundaries of your app so that the type system can work _extremely_ well.

[0]: https://zod.dev/ note: I mentioned Zod because I like it. There are _many_ similar libraries.

Zod is an open-source schema declaration and validation library that emphasizes TypeScript. It can refer to any data type, from simple to complex. Zod eliminates duplicative type declarations by inferring static TypeScript types and allows easy composition of complex data structures from simpler ones. It has no dependencies, is compatible with Node.js and modern browsers, and has a concise, chainable interface. Zod is lightweight (8kb when zipped), immutable, with methods returning new instances. It encourages parsing over validation and is not limited to TypeScript but works well with JavaScript as well.

Zod is a TypeScript-first schema declaration and validation library. It helps create schemas for any data type and is very developer-friendly. Zod has the functional approach of "parse, don't validate." It supports coercion in all primitive types.

Link: https://zod.dev/

You can check out their documentation here.

You can learn more about Zod on their website here.

In JS, it's a good idea anyway to use some JSON parsing library instead of JSON.parse.

With Zod, you can use z.bigint() parser. If you take the "parse any JSON" snippet https://zod.dev/?id=json-type and change z.number() to z.bigint(), it should do what you are looking for.

We will validate our input using client-side zod. Zod handles TypeScript-first schema validation with static type inference. This means that it will not only validate your fields, it will also set types on validated fields.