TypeScript icon, indicating that this package has built-in type declarations

1.6.1 • Public • Published


A library to convert complex JSON Schema to Scala Case Classes. Supports both NodeJs and Browser environments.

Build Status npm version License PRs Welcome PRs Welcome

Try Online Editor


JSON Schema Generated Scala Case Classes
  "title": "Product",
  "type": "object",
  "required": [ "productId", "productName", "price" ],
  "properties": {
    "productId": { "type": "integer" },
    "productName": { "type": "string" },
    "price": { "type": "number" },
    "tags": {
      "type": "array",
      "items": { "type": "string" }
    "dimensions": {
      "type": "object",
      "properties": {
        "length": { "type": "number" },
        "width": { "type": "number" },
        "height": { "type": "number" }
case class Product (
   productId: Integer,
   productName: String,
   price: Double,
   tags: Option[List[String]],
   dimensions: Option[Dimensions]
case class Dimensions (
   length: Double,
   width: Double,
   height: Double


  1. Resolve local as well as remote schema references.
  2. Handle nested JSON schema objects.
  3. Can wrap optional fields in Option[].
  4. Support constraint validations through assertion.
  5. Generate scaladoc based on the description provided in JSON Schema.
  6. Support various text cases for case class and parameter names.
  7. Can default to provided generic type. (default Any)
  8. Can build Enumeration objects for properties with enum field.


npm install --save json-schema-to-case-class


Usage - Node

For NodeJs (TypeScript):

import { convert, IConfig } from 'json-schema-to-case-class'

const mySchema: any = { ... };
const config: IConfig = { ... };  // <-- Optional

// With default configuration:
convert( mySChema )
  .then( result => console.log(result) )
  .catch( err => console.error(err) )

// With custom configuration:
convert( mySchema, config )
  .then( result => console.log(result) )
  .catch( err => console.error(err) )

For NodeJs (JavaScript):

const { convert } = require('json-schema-to-case-class');
// OR
const SchemaConverter = require('json-schema-to-case-class');
SchemaConverter.convert( , );


If you are building this for a use in browser, you will need to include the following pollyfills:

 http: require.resolve('http-browserify'),
 https: require.resolve('https-browserify'),
 stream: require.resolve('stream-browserify')

Check webpack.config.js for example configuration.

Usage - Prebuilt Bundle

For browser: If you are using the prebuild bundle, it has all the APIs under SchemaConverter global object:

SchemaConverter.convert( mySchema, config )


It is optional to pass configuration object. Every configuration setting is optional as well. When not passed, default kicks-in. IConfig:

Name Type Description Default
maxDepth number Parses nested schema objects upto the depth = maxDepth. Pass 0 for no limit on depth. 0
optionSetting string Setting to wrap optional parameters in Option[].
1. "useOptions" - Wrap optional parameters in Option[]
2. "useOptionsForAll" - Wrapp all parameters in Option[]
3. "noOptions" - Don't wrap any parameter in Option[]
classNameTextCase string Text case for case class title. Could be one of:
camelCase, capitalCase, constantCase, dotCase, headerCase, noCase, paramCase, pascalCase, pathCase, sentenceCase, snakeCase
classParamsTextCase string Text case for case class parameters. Could be one of above. snakeCase
topLevelCaseClassName string This config kicks-in only if top level schema object does not have 'title' property. MyCaseClass
defaultGenericType string Case class parameter type when type information not available from the schema or if we are converting partial schema using maxDepth setting. Any
parseRefs boolean Whether to resolve the local or remote schema references ($ref). true
generateComments boolean Whether to generate scaladoc-like comments for the case class generated. false
generateValidations boolean Whether to generate validations in the form of assertions in case class body. false
generateEnumerations boolean Whether to generate enumerations for enum fields. It generates an object extending scala's Enumeration class and use it in parameter type. false


It also comes with the CLI. Install the package globally and run:

js2cc --help

OR use with npx

npx js2cc --help
Usage: js2cc <src> [options]

Convert JSON schemas into scala case class

  src                                       Path to json schema. It must be a local file. Support for reading URLs will be added in future version.

  -v, --version                             Library version
  -d, --max-depth <number>                  Maximum depth to parse nested JSON schema (default: 0)
  -s, --option-setting <type>               Wrap non-required fields in `Option` (choices: "noOptions", "useOptions", "useOptionsForAll", default: "useOptions")
  -n, --top-level-case-class-name <string>  Name of the top-level case class (Applies only if JSON schema does not have top-level `title` property. (default: "MyCaseClass")
  -d, --default-generic-type <string>       Default generic type for unparsable data types (default: "Any")
  -p, --parse-refs                          Parse local and remote references (default: true)
  -c, --generate-comments                   Generate scaladoc comments (default: false)
  -v, --generate-validations                Generate assertions from validations in JSON schema (default: false)
  -e, --generate-enumerations               Generate enumerations (default: false)
  -o, --output <string>                     File name to write output to. If not provided, output will be written to console. (default: false)
  -D, --debug                               Write more detailed output to console (default: false)
  -h, --help                                display help for command

Example call:
  $ js2cc ./local/sample-schema.json -n Person -s useOptions -o sample-output.scala --debug

Browser Support

This library supports recent versions of every major web browsers. Refer to the browserified build dist/js2cc.min.js that you can directly use in <script /> tag of HTML page. It already bundles all the required polyfills.


  • Schema Compositions - It currently only supports allOf. Support for anyOf and oneOf will be added in future releases.


All contributions, enhancements, and bug-fixes are welcome. Open an issue or create a pull request.

Building locally

  1. Clone the repo

  2. Install Dependancies
    npm install

  3. Setup development environment
    npm run setup-dev-env

  4. Run the test
    npm test

  5. Run eslint checks
    npm run lint

  6. Run eslint checks and fix the errors
    npm run lint:fix

Package Sidebar


Weekly Downloads






Unpacked Size

1.16 MB

Total Files


Last publish


  • cchandurkar