ts-simple-type
ts-to-zod
ts-simple-type | ts-to-zod | |
---|---|---|
3 | 4 | |
35 | 996 | |
- | - | |
0.0 | 8.0 | |
about 1 year ago | 6 days ago | |
TypeScript | TypeScript | |
MIT License | MIT License |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
ts-simple-type
-
tRPC – Move Fast and Break Nothing. End-to-end typesafe APIs made easy
We use an internal validator library that we infer request types from. It’s similar to Zod (but also predates it by a year).
I’ve also spent some time on a Typescript type to X compiler. My first prototype is open source and targets Thrift, Proto3, Python, and JSON schema: https://github.com/justjake/ts-simple-type/tree/main/src/com...
I’m not happy with the design decision in that codebase to try to “simplify” Typescript types before compiling, and probably won’t continue that implementation, but we have a few internal code generators that consume TS types and output test data builders and model clases we use in production.
- Ezno
-
Ultra-minimal JSON schemas with TypeScript inference
After some frustration with the TypeScript schema library ecosystem, I've decided that I'd prefer to declare my types using TypeScript's excellent type syntax, so I can take advantage of generics, mapped types, etc. Then, I'll take those TypeScript types and compile them to whatever alternative schema format I need.
There are many libraries that claim to convert your Typescript types to other formats, such as ts-json-schema-generator, ts-to-zod, or typeconv/core-types-ts. These libraries work by interpreting the Typescript AST, essentially re-implementing a bare-bones type system from scratch. Most do not support advanced Typescript features like generic application, mapped types, or string literal types. So, what's the point? To avoid those limitations, I use Typescript's first-party ts.TypeChecker API to analyze types, and an existing library called ts-simple-type (which I've forked) to convert from ts.Type to a more usable intermediate format. Then, I recurse over the intermediate format and emit "AST nodes". It's pretty simple, but seems promising.
So far, I have compilers from TypeScript type to Python 3 and Thrift. But I plan to add OpenAPI/JSONSchema, Protobuf (Proto3), Kotlin, Swift, and maybe Zod and Avro. Each target language is around ~300 LoC so they're pretty easy to put together.
Repo: https://github.com/justjake/ts-simple-type
Compiler input and output: https://github.com/justjake/ts-simple-type/blob/jake--compil...
Thrift compiler: https://github.com/justjake/ts-simple-type/blob/jake--compil...
Python compiler: https://github.com/justjake/ts-simple-type/blob/jake--compil...
ts-to-zod
-
How to parse json into typescript types?
You could use something like this https://github.com/fabien0102/ts-to-zod
-
Ultra-minimal JSON schemas with TypeScript inference
YES! I've introduced ts-to-zod into my codebase only yesterday, and it's served my needs exactly. It doesn't handle generics or mapped types, but that's a fair price to pay.
It also works the other way, you can define a zod schema and you can infer types for your data from it.
https://github.com/fabien0102/ts-to-zod
-
Generating dummy entities with random data for tests based on types
The closest that I know of (and I have not used this) is zod-fast-check. It generates fast-check “arbitraries” (test data generators) for property-based testing based on zod schemas. Of course, this requires that you use zod to define your types, which has some downsides. Fortunately there is another tool, ts-to-zod, (which I also have not used) which will codegen zod schemas based on TS type definitions. If you thread these four libraries together you should end up with the ability to write random tests on generated data with very little overhead. In theory.
-
Runtime Data Validation from TypeScript Interfaces
Okay, that's an improvement! We can use TypeScript's native type syntax to define the interface, and augment it with JSDoc comments for any properties that can't be natively expressed. So, to use this with Zod, we need to convert it from the TypeScript syntax to the Zod syntax. Luckily, Fabien Bernard has spearheaded the excellent ts-to-zod project, which looks through interfaces defined in a file and outputs the equivalent Zod schemata for them.
What are some alternatives?
fern-java - Generate Java models, clients, and server interfaces from your API definition.
zod - TypeScript-first schema validation with static type inference
telefunc - Remote Functions. Instead of API.
ts-ast-viewer - TypeScript AST viewer.
stytch-t3-example - An example app demonstrating how to use Stytch within the T3 stack
ts-patch - Augment the TypeScript compiler to support extended functionality
vellum-client-python - Python SDK for Vellum API
spartan-schema - Ultra-minimal JSON schemas with Typescript inference
vellum-client-generator - Vellum’s Fern API which is used to generate SDKs.
intermock - Mocking library to create mock objects with fake data for TypeScript interfaces
quicktype - Generate types and converters from JSON, Schema, and GraphQL