typescript-json-schema

For anyone using both TypeScript and JSON schemas, but wanting to use TypeScript as the source of truth, I highly recommend the following library: [ts-json-schema-generator](https://github.com/YousefED/typescript-json-schema). It does exactly what it says in the box: turns your TypeScript `types` / `interface` into machine-readable JSON schemas. The library has a few open issues (does not deal well with some edge cases of composing Omit<> on sum types, and does not support dynamic (const) keys), but compared to manually writing JSON schemas, it's been amazing! EDIT: I should add that the library supports adding further type constraints that are supported by JSON Schema but not by TS by using JSDoc (for instance, pattern matching on strings, ranges on numbers, etc.).

> For more complex cases I find myself wishing I could just turn Typescript into some kind of schema validation for JSON. Not sure if this is what you're looking for, and whether it's powerful and expressive enough for your use case, but you can use typescript-json-schema¹ for this, and validate with eg ajv. ¹https://github.com/YousefED/typescript-json-schema

This is why I originally started a project to convert ts to json schema; https://github.com/YousefED/typescript-json-schema (and also check out a good alternative https://github.com/vega/ts-json-schema-generator)

Should be technically possible, though I don't know how strictly they map to/from each other. JSON schema to TypeScript - https://github.com/bcherny/json-schema-to-typescript TypeScript to JSON schema - https://github.com/YousefED/typescript-json-schema

Thank you - yes, I've dabbled with io-ts, though I'm still learning how to wield its power. > Opt-in runtime checks for SQL queries Ah right, I do see in the repo for PgTyped that it's on the roadmap. That does sound useful! I'm hoping that one of these days, TypeScript will support a more generic runtime type check, somehow closer to the language/TSC-level rather than userland libraries, plugins/transforms, or a parallel compiler/build step. At the moment, I use a fork of typescript-json-schema ¹ for my purposes. ¹ https://github.com/YousefED/typescript-json-schema

You can generate JSON Schema from TS with this library: https://github.com/YousefED/typescript-json-schema It's certainly conceivable to build an equivalent for Zod but you'll eventually want to validate types that aren't expressible in TS (i.e. Integer).

If you define the types in TS, you can use https://github.com/YousefED/typescript-json-schema to automatically generate a JSON schema from it. That way, configurations can be specified either in an executable JS module or in a JSON file.

1. Use discriminated union types: https://www.typescriptlang.org/docs/handbook/advanced-types.... - TypeScript these days sticks with the runtime semantics of JavaScript, and discriminated unions are a very natural way to express algebraic data types in JS. 2. Use https://github.com/YousefED/typescript-json-schema to generate a JSON schema, then use a json schema validator to do runtime validation. That's how https://github.com/Polymer/tachometer handles config file parsing and it works very well.

This is a very powerful approach because there are json schema libraries available in all major languages. TypeScript is a better source for truth because it can represent things json schema can't. It is possible to generate a json schema from a TypeScript definition (see https://github.com/YousefED/typescript-json-schema), which means TypeScript can be the single source of truth for API definitions, be used directly in the frontend and, in json schema form, used to test directly against API responses.

This is very cool, but I highly recommend using a standard like JSON schema instead. It will make your life easier long term. The initial hurdle of learning may be harder, but lots of libraries/languages support JSON schema. If you are using typescript, I highly recommend using a generator to create JSON schema definitions. This one has worked really well recently https://github.com/YousefED/typescript-json-schema

An alternative I'm a fan of: using typescript-json-schema: https://github.com/YousefED/typescript-json-schema To turn TypeScript interfaces into JSON schemas, then evaluating incoming JSON using whatever JSON schema validation library you want. It's a tradeoff though, as this replaces the need for "t.TypeOf" with some kind of separate build step that creates the schemas. I still prefer it though, as it allows me to use standard TS interfaces rather than any kind of custom format.

No, there's nothing wrong with that and it's usually significantly more readable than JSON Schema. Good idea! Of course there are use cases that JSON Schema works better for (eg most other replies you got) but I fully agree that TypeScript type definitions are a great way to specify the structure of JSON data. To make it feel more language-agnostic, you could consider using type aliases instead: type Person = { firstName: string, lastName: string, age?: number // Age in years } This is equivalent to the interface you described, but potentially less confusing to readers who don't know what an "interface" is (eg because they mostly used Ruby or C++). You don't even need to tell people that it's TypeScript - this could be a perfectly sensible schema language for JSON. A bit like what RELAX NG[0] is for XML. A

Yes, a runtime check in TypeScript is the same as a runtime check in JavaScript. function inc(n) { if (typeof n === 'number') { return n + 1 } throw new Error('Parameter n is not a number'); } If you wanted to actually runtime check all types (probably not advised) you could parse the type annotations. Or you could define your types using something like JSON Schema and validate against that. https://github.com/bcherny/json-schema-to-typescript https://github.com/YousefED/typescript-json-schema

Maybe something like this? https://github.com/YousefED/typescript-json-schema