json-schema-to-typescript vs typescript-json-schema
TypeScript Schema Generation Libraries Comparison
Search packages..
1 Year
json-schema-to-typescripttypescript-json-schema
What's TypeScript Schema Generation Libraries?

TypeScript schema generation libraries are tools that facilitate the conversion of JSON Schema definitions into TypeScript types, enhancing type safety and reducing boilerplate code in TypeScript applications. These libraries help developers maintain consistency between data structures defined in JSON Schema and their TypeScript counterparts, ensuring that the application adheres to the defined data contracts. By automating the type generation process, these libraries streamline development workflows and improve code maintainability.

Package Weekly Downloads Trend
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
json-schema-to-typescript762,3883,014201 kB164a month agoMIT
typescript-json-schema531,3643,196262 kB1786 months agoBSD-3-Clause
Feature Comparison: json-schema-to-typescript vs typescript-json-schema

Type Safety

  • json-schema-to-typescript:

    json-schema-to-typescript provides strong type safety by generating TypeScript interfaces that directly correspond to the JSON Schema definitions. This ensures that any data conforming to the schema will be type-checked at compile time, reducing runtime errors and improving code reliability.

  • typescript-json-schema:

    typescript-json-schema also generates TypeScript types from JSON Schema but focuses on leveraging existing TypeScript types and interfaces. It allows for more complex type definitions and can integrate with existing TypeScript codebases, ensuring that the types generated are consistent with the existing code.

Ease of Use

  • json-schema-to-typescript:

    json-schema-to-typescript is designed for simplicity and ease of use. It has a straightforward API and requires minimal configuration, making it accessible for developers who want to quickly generate TypeScript types from JSON Schema without extensive setup.

  • typescript-json-schema:

    typescript-json-schema may require a deeper understanding of TypeScript and its type system. While it offers powerful features, the learning curve can be steeper for developers who are not familiar with TypeScript's advanced type capabilities.

Customization

  • json-schema-to-typescript:

    json-schema-to-typescript allows for some customization in the type generation process, enabling developers to specify options that affect how the types are generated, such as prefixing or suffixing type names.

  • typescript-json-schema:

    typescript-json-schema provides extensive customization options, allowing developers to control the output format, include or exclude specific properties, and even generate schemas from existing TypeScript types, offering greater flexibility in how types are defined.

Integration

  • json-schema-to-typescript:

    json-schema-to-typescript can be easily integrated into build processes and workflows, making it suitable for projects that require automated type generation as part of their development pipeline.

  • typescript-json-schema:

    typescript-json-schema is particularly well-suited for projects that already use TypeScript extensively, as it can generate schemas from existing TypeScript code, facilitating better integration with TypeScript-based applications.

Community and Support

  • json-schema-to-typescript:

    json-schema-to-typescript has a growing community and is actively maintained, providing a decent level of support and documentation for developers.

  • typescript-json-schema:

    typescript-json-schema has a larger community and more extensive documentation, which can be beneficial for developers seeking help and resources when working with the library.

How to Choose: json-schema-to-typescript vs typescript-json-schema
  • json-schema-to-typescript:

    Choose json-schema-to-typescript if you need a straightforward solution for converting JSON Schema to TypeScript interfaces with a focus on type safety and simplicity. It is particularly useful for projects that require a clean and direct mapping from JSON Schema to TypeScript types without additional complexities.

Similar Npm Packages to json-schema-to-typescript

json-schema-to-typescript is a powerful npm package that allows developers to convert JSON Schema definitions into TypeScript interfaces. This tool is particularly useful for ensuring type safety in TypeScript applications when working with data that conforms to a JSON Schema. By generating TypeScript types directly from the schema, developers can reduce the risk of runtime errors and improve code maintainability. The package supports various options for customization, allowing users to tailor the generated types to their specific needs.

An alternative to json-schema-to-typescript is typescript-json-schema. This package generates JSON Schema from TypeScript types, enabling developers to create a schema that accurately reflects their TypeScript interfaces. This is particularly useful for projects that start with TypeScript types and need to expose a JSON Schema for validation or documentation purposes. While both libraries serve the purpose of bridging TypeScript and JSON Schema, they approach the problem from different angles: json-schema-to-typescript focuses on converting schemas to TypeScript types, while typescript-json-schema focuses on generating schemas from TypeScript types.

To explore the comparison between these two packages, visit: Comparing json-schema-to-typescript vs typescript-json-schema.

Similar Npm Packages to typescript-json-schema

typescript-json-schema is a powerful npm package that generates JSON Schema from TypeScript types. This tool is particularly useful for developers who want to validate JSON data against TypeScript interfaces, ensuring that the data conforms to the expected structure. By generating JSON Schema, it allows for better interoperability between TypeScript and other systems that utilize JSON Schema for validation and documentation purposes.

While typescript-json-schema is a robust solution, there are alternatives available that serve similar purposes. One notable alternative is:

  • json-schema-to-typescript. This library provides the ability to convert JSON Schema definitions into TypeScript types. It is particularly useful for developers who work with APIs that provide JSON Schema documentation and want to generate corresponding TypeScript interfaces. By using json-schema-to-typescript, developers can easily ensure that their TypeScript code aligns with the JSON Schema definitions, facilitating type safety and reducing the risk of runtime errors.

For a detailed comparison between typescript-json-schema and json-schema-to-typescript, you can visit the following link: Comparing typescript-json-schema vs json-schema-to-typescript.

README for json-schema-to-typescript

json-schema-to-typescript Build Status npm mit node

Compile JSON Schema to TypeScript typings.

Example

Check out the live demo.

Input:

{
  "title": "Example Schema",
  "type": "object",
  "properties": {
    "firstName": {
      "type": "string"
    },
    "lastName": {
      "type": "string"
    },
    "age": {
      "description": "Age in years",
      "type": "integer",
      "minimum": 0
    },
    "hairColor": {
      "enum": ["black", "brown", "blue"],
      "type": "string"
    }
  },
  "additionalProperties": false,
  "required": ["firstName", "lastName"]
}

Output:

export interface ExampleSchema {
  firstName: string;
  lastName: string;
  /**
   * Age in years
   */
  age?: number;
  hairColor?: "black" | "brown" | "blue";
}

Installation

npm install json-schema-to-typescript

Usage

json-schema-to-typescript is easy to use via the CLI, or programmatically.

CLI

First make the CLI available using one of the following options:

# install locally, then use `npx json2ts`
npm install json-schema-to-typescript

# or install globally, then use `json2ts`
npm install json-schema-to-typescript --global

# or install to npm cache, then use `npx --package=json-schema-to-typescript json2ts`
# (you don't need to run an install command first)

Then, use the CLI to convert JSON files to TypeScript typings:

cat foo.json | json2ts > foo.d.ts
# or
json2ts foo.json > foo.d.ts
# or
json2ts foo.yaml foo.d.ts
# or
json2ts --input foo.json --output foo.d.ts
# or
json2ts -i foo.json -o foo.d.ts
# or (quote globs so that your shell doesn't expand them)
json2ts -i 'schemas/**/*.json'
# or
json2ts -i schemas/ -o types/

You can pass any of the options described below (including style options) as CLI flags. Boolean values can be set to false using the no- prefix.

# generate code for definitions that aren't referenced
json2ts -i foo.json -o foo.d.ts --unreachableDefinitions
# use single quotes and disable trailing semicolons
json2ts -i foo.json -o foo.d.ts --style.singleQuote --no-style.semi

API

To invoke json-schema-to-typescript from your TypeScript or JavaScript program, import it and call compile or compileFromFile.

import { compile, compileFromFile } from 'json-schema-to-typescript'

// compile from file
compileFromFile('foo.json')
  .then(ts => fs.writeFileSync('foo.d.ts', ts))

// or, compile a JS object
let mySchema = {
  properties: [...]
}
compile(mySchema, 'MySchema')
  .then(ts => ...)

See server demo and browser demo for full examples.

Options

compileFromFile and compile accept options as their last argument (all keys are optional):

| key | type | default | description | |-|-|-|-| | additionalProperties | boolean | true | Default value for additionalProperties, when it is not explicitly set | | bannerComment | string | "/* eslint-disable */\n/**\n* This file was automatically generated by json-schema-to-typescript.\n* DO NOT MODIFY IT BY HAND. Instead, modify the source JSON Schema file,\n* and run json-schema-to-typescript to regenerate this file.\n*/" | Disclaimer comment prepended to the top of each generated file | | customName | (LinkedJSONSchema, string \| undefined) => string \| undefined | undefined | Custom function to provide a type name for a given schema | cwd | string | process.cwd() | Root directory for resolving $refs | | declareExternallyReferenced | boolean | true | Declare external schemas referenced via $ref? | | enableConstEnums | boolean | true | Prepend enums with const? | | inferStringEnumKeysFromValues | boolean | false | Create enums from JSON enums with eponymous keys | | format | boolean | true | Format code? Set this to false to improve performance. | | ignoreMinAndMaxItems | boolean | false | Ignore maxItems and minItems for array types, preventing tuples being generated. | | maxItems | number | 20 | Maximum number of unioned tuples to emit when representing bounded-size array types, before falling back to emitting unbounded arrays. Increase this to improve precision of emitted types, decrease it to improve performance, or set it to -1 to ignore maxItems. | strictIndexSignatures | boolean | false | Append all index signatures with \| undefined so that they are strictly typed. | | style | object | { bracketSpacing: false, printWidth: 120, semi: true, singleQuote: false, tabWidth: 2, trailingComma: 'none', useTabs: false } | A Prettier configuration | | unknownAny | boolean | true | Use unknown instead of any where possible | | unreachableDefinitions | boolean | false | Generates code for $defs that aren't referenced by the schema. | | $refOptions | object | {} | $RefParser Options, used when resolving $refs |

Tests

$ npm test

Features

  • [x] title => interface
  • [x] Primitive types:
    • [x] array
    • [x] homogeneous array
    • [x] boolean
    • [x] integer
    • [x] number
    • [x] null
    • [x] object
    • [x] string
    • [x] homogeneous enum
    • [x] heterogeneous enum
  • [x] Non/extensible interfaces
  • [ ] Custom JSON-schema extensions
  • [x] Nested properties
  • [x] Schema definitions
  • [x] Schema references
  • [x] Local (filesystem) schema references
  • [x] External (network) schema references
  • [x] Add support for running in browser
  • [x] default interface name
  • [x] infer unnamed interface name from filename
  • [x] deprecated
  • [x] allOf ("intersection")
  • [x] anyOf ("union")
  • [x] oneOf (treated like anyOf)
  • [x] maxItems (eg)
  • [x] minItems (eg)
  • [x] additionalProperties of type
  • [x] patternProperties (partial support)
  • [x] extends
  • [x] required properties on objects (eg)
  • [ ] validateRequired (eg)
  • [x] literal objects in enum (eg)
  • [x] referencing schema by id (eg)
  • [x] custom typescript types via tsType

Custom schema properties:

  • tsType: Overrides the type that's generated from the schema. Useful for forcing a type to any or when using non-standard JSON schema extensions (eg).
  • tsEnumNames: Overrides the names used for the elements in an enum. Can also be used to create string enums (eg).

Not expressible in TypeScript:

FAQ

JSON-Schema-to-TypeScript is crashing on my giant file. What can I do?

Prettier is known to run slowly on really big files. To skip formatting and improve performance, set the format option to false.

Further Reading

  • JSON-schema spec: https://tools.ietf.org/html/draft-zyp-json-schema-04
  • JSON-schema wiki: https://github.com/json-schema/json-schema/wiki
  • JSON-schema test suite: https://github.com/json-schema/JSON-Schema-Test-Suite/blob/node
  • TypeScript spec: https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md

Who uses JSON-Schema-to-TypeScript?

npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc or npmjs.com, the official website for the npm registry. Please note that npm is a registered trademark of npm, Inc. For more details, please refer to our Terms & Privacy.