cleanup: use defs internally, not definitions

Author: Boris Cherny

README.md

@@ -93,7 +93,7 @@ See [server demo](example) and [browser demo](https://github.com/bcherny/json-sc
 | 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`.
 | style | object | `{ bracketSpacing: false,  printWidth: 120,  semi: true,  singleQuote: false,  tabWidth: 2,  trailingComma: 'none',  useTabs: false }` | A [Prettier](https://prettier.io/docs/en/options.html) configuration |
 | unknownAny | boolean | `true` | Use `unknown` instead of `any` where possible |
-| unreachableDefinitions | boolean | `false` | Generates code for `definitions` that aren't referenced by the schema. |
+| unreachableDefinitions | boolean | `false` | Generates code for `$defs` that aren't referenced by the schema. |
 | strictIndexSignatures | boolean | `false` | Append all index signatures with `\| undefined` so that they are strictly typed. |
 | $refOptions | object | `{}` | [$RefParser](https://github.com/BigstickCarpet/json-schema-ref-parser) Options, used when resolving `$ref`s |
 ## CLI

src/normalizer.ts

@@ -2,6 +2,7 @@ import {JSONSchemaTypeName, LinkedJSONSchema, NormalizedJSONSchema, Parent} from
 import {appendToDescription, escapeBlockComment, isSchemaLike, justName, toSafeString, traverse} from './utils'
 import {Options} from './'
 import {DereferencedPaths} from './resolver'
+import {isDeepStrictEqual} from 'util'
 
 type Rule = (
   schema: LinkedJSONSchema,
@@ -202,10 +203,15 @@ rules.set('Make extends always an array, if it is defined', schema => {
   }
 })
 
-rules.set('Transform $defs to definitions', schema => {
-  if (schema.$defs) {
-    schema.definitions = schema.$defs
-    delete schema.$defs
+rules.set('Transform definitions to $defs', (schema, fileName) => {
+  if (schema.definitions && schema.$defs && !isDeepStrictEqual(schema.definitions, schema.$defs)) {
+    throw ReferenceError(
+      `Schema must define either definitions or $defs, not both. Given id=${schema.id} in ${fileName}`
+    )
+  }
+  if (schema.definitions) {
+    schema.$defs = schema.definitions
+    delete schema.definitions
   }
 })
 

src/parser.ts

@@ -384,7 +384,7 @@ via the \`patternProperty\` "${key}".`
 
   if (options.unreachableDefinitions) {
     asts = asts.concat(
-      map(schema.definitions, (value, key: string) => {
+      map(schema.$defs, (value, key: string) => {
         const ast = parse(value, options, key, processed, usedNames)
         const comment = `This interface was referenced by \`${parentSchemaName}\`'s JSON-Schema
 via the \`definition\` "${key}".`
@@ -453,7 +453,7 @@ function getDefinitions(
   }
   if (isPlainObject(schema)) {
     return {
-      ...(isSchema && hasDefinitions(schema) ? schema.definitions : {}),
+      ...(isSchema && hasDefinitions(schema) ? schema.$defs : {}),
       ...Object.keys(schema).reduce<Definitions>(
         (prev, cur) => ({
           ...prev,
@@ -472,5 +472,5 @@ const getDefinitionsMemoized = memoize(getDefinitions)
  * TODO: Reduce rate of false positives
  */
 function hasDefinitions(schema: LinkedJSONSchema): schema is JSONSchemaWithDefinitions {
-  return 'definitions' in schema
+  return '$defs' in schema
 }

src/types/JSONSchema.ts

@@ -70,7 +70,7 @@ export interface NormalizedJSONSchema extends LinkedJSONSchema {
   additionalProperties: boolean | NormalizedJSONSchema
   extends?: string[]
   items?: NormalizedJSONSchema | NormalizedJSONSchema[]
-  definitions?: {
+  $defs?: {
     [k: string]: NormalizedJSONSchema
   }
   properties?: {
@@ -89,6 +89,7 @@ export interface NormalizedJSONSchema extends LinkedJSONSchema {
   required: string[]
 
   // Removed by normalizer
+  definitions: never
   id: never
 }
 
@@ -108,7 +109,7 @@ export interface SchemaSchema extends NormalizedJSONSchema {
 }
 
 export interface JSONSchemaWithDefinitions extends NormalizedJSONSchema {
-  definitions: {
+  $defs: {
     [k: string]: NormalizedJSONSchema
   }
 }

src/utils.ts

@@ -14,6 +14,7 @@ export function Try<T>(fn: () => T, err: (e: Error) => any): T {
 // keys that shouldn't be traversed by the catchall step
 const BLACKLISTED_KEYS = new Set([
   'id',
+  '$defs',
   '$id',
   '$schema',
   'title',
@@ -121,6 +122,9 @@ export function traverse(
   if (schema.definitions) {
     traverseObjectKeys(schema.definitions, callback, processed)
   }
+  if (schema.$defs) {
+    traverseObjectKeys(schema.$defs, callback, processed)
+  }
   if (schema.not) {
     traverse(schema.not, callback, processed)
   }
@@ -362,13 +366,14 @@ export function isSchemaLike(schema: LinkedJSONSchema) {
   }
 
   const JSON_SCHEMA_KEYWORDS = [
+    '$defs',
     'allOf',
     'anyOf',
+    'definitions',
     'dependencies',
     'enum',
-    'oneOf',
-    'definitions',
     'not',
+    'oneOf',
     'patternProperties',
     'properties',
     'required'

test/normalizer/destructureUnaryTypes.json

@@ -26,8 +26,7 @@
   },
   "out": {
     "$id": "foo",
-    "type": "object",
-    "definitions": {
+    "$defs": {
       "a": {
         "type": "integer",
         "$id": "a"
@@ -39,6 +38,7 @@
         "$id": "b"
       }
     },
+    "type": "object",
     "additionalProperties": true,
     "required": []
   }

test/normalizer/normalizeDefs.json

@@ -1,14 +1,14 @@
 {
-  "name": "Normalize $defs to definitions",
+  "name": "Normalize definitions to $defs",
   "in": {
     "$id": "foo",
-    "$defs": {
+    "definitions": {
       "bar": "baz"
     }
   },
   "out": {
     "$id": "foo",
-    "definitions": {
+    "$defs": {
       "bar": "baz"
     }
   }