Intersection schema generation is order-dependent

src/applySchemaTyping.ts

@@ -0,0 +1,51 @@
+import type {LinkedJSONSchema} from './types/JSONSchema'
+import {Intersection, Parent, Types} from './types/JSONSchema'
+import {typesOfSchema} from './typesOfSchema'
+
+export function applySchemaTyping(schema: LinkedJSONSchema) {
+  const types = typesOfSchema(schema)
+
+  Object.defineProperty(schema, Types, {
+    enumerable: false,
+    value: types,
+    writable: false,
+  })
+
+  if (types.size === 1) {
+    return
+  }
+
+  // Some schemas can be understood as multiple possible types (see related
+  // comment in `typesOfSchema.ts`). In such cases, we generate an `ALL_OF`
+  // intersection that will ultimately be used to generate a union type.
+  //
+  // The original schema's name, title, and description are hoisted to the
+  // new intersection schema to prevent duplication.
+  //
+  // If the original schema also contained its own `ALL_OF` property, it is
+  // also hoiested to the new intersection schema.
+  const intersection = {
+    [Parent]: schema,
+    [Types]: new Set(['ALL_OF']),
+    $id: schema.$id,
+    description: schema.description,
+    name: schema.name,
+    title: schema.title,
+    allOf: schema.allOf ?? [],
+    required: [],
+    additionalProperties: false,
+  }
+
+  types.delete('ALL_OF')
+  delete schema.allOf
+  delete schema.$id
+  delete schema.description
+  delete schema.name
+  delete schema.title
+
+  Object.defineProperty(schema, Intersection, {
+    enumerable: false,
+    value: intersection,
+    writable: false,
+  })
+}

src/normalizer.ts

@@ -1,6 +1,7 @@
 import {JSONSchemaTypeName, LinkedJSONSchema, NormalizedJSONSchema, Parent} from './types/JSONSchema'
 import {appendToDescription, escapeBlockComment, isSchemaLike, justName, toSafeString, traverse} from './utils'
 import {Options} from './'
+import {applySchemaTyping} from './applySchemaTyping'
 import {DereferencedPaths} from './resolver'
 import {isDeepStrictEqual} from 'util'
 
@@ -222,6 +223,22 @@ rules.set('Transform const to singleton enum', schema => {
   }
 })
 
+// Precalculation of the schema types is necessary because the ALL_OF type
+// is implemented in a way that mutates the schema object. Detection of the
+// NAMED_SCHEMA type relies on the presence of the $id property, which is
+// hoisted to a parent schema object during the ALL_OF type implementation,
+// and becomes unavailable if the same schema is used in multiple places.
+//
+// Precalculation of the `ALL_OF` intersection schema is necessary because
+// the intersection schema needs to participate in the schema cache during
+// the parsing step, so it cannot be re-calculated every time the schema
+// is encountered.
+rules.set('Pre-calculate schema types and intersections', schema => {
+  if (schema !== null && typeof schema === 'object') {
+    applySchemaTyping(schema)
+  }
+})
+
 export function normalize(
   rootSchema: LinkedJSONSchema,
   dereferencedPaths: DereferencedPaths,

src/parser.ts

@@ -2,36 +2,25 @@ import {JSONSchema4Type, JSONSchema4TypeName} from 'json-schema'
 import {findKey, includes, isPlainObject, map, memoize, omit} from 'lodash'
 import {format} from 'util'
 import {Options} from './'
-import {typesOfSchema} from './typesOfSchema'
-import {
-  AST,
-  T_ANY,
-  T_ANY_ADDITIONAL_PROPERTIES,
-  TInterface,
-  TInterfaceParam,
-  TNamedInterface,
-  TTuple,
-  T_UNKNOWN,
-  T_UNKNOWN_ADDITIONAL_PROPERTIES,
-  TIntersection,
-} from './types/AST'
-import {
-  getRootSchema,
-  isBoolean,
-  isPrimitive,
-  JSONSchema as LinkedJSONSchema,
+import {applySchemaTyping} from './applySchemaTyping'
+import type {AST, TInterface, TInterfaceParam, TIntersection, TNamedInterface, TTuple} from './types/AST'
+import {T_ANY, T_ANY_ADDITIONAL_PROPERTIES, T_UNKNOWN, T_UNKNOWN_ADDITIONAL_PROPERTIES} from './types/AST'
+import type {
   JSONSchemaWithDefinitions,
+  LinkedJSONSchema,
+  NormalizedJSONSchema,
   SchemaSchema,
   SchemaType,
 } from './types/JSONSchema'
-import {generateName, log, maybeStripDefault, maybeStripNameHints} from './utils'
+import {Intersection, Types, getRootSchema, isBoolean, isPrimitive} from './types/JSONSchema'
+import {generateName, log, maybeStripDefault} from './utils'
 
-export type Processed = Map<LinkedJSONSchema, Map<SchemaType, AST>>
+export type Processed = Map<NormalizedJSONSchema, Map<SchemaType, AST>>
 
 export type UsedNames = Set<string>
 
 export function parse(
-  schema: LinkedJSONSchema | JSONSchema4Type,
+  schema: NormalizedJSONSchema | JSONSchema4Type,
   options: Options,
   keyName?: string,
   processed: Processed = new Map(),
@@ -45,41 +34,32 @@ export function parse(
     return parseLiteral(schema, keyName)
   }
 
-  const types = typesOfSchema(schema)
-  if (types.length === 1) {
-    const ast = parseAsTypeWithCache(schema, types[0], options, keyName, processed, usedNames)
-    log('blue', 'parser', 'Types:', types, 'Input:', schema, 'Output:', ast)
+  const intersection = schema[Intersection]
+  const types = schema[Types]
+
+  if (intersection) {
+    const ast = parseAsTypeWithCache(intersection, 'ALL_OF', options, keyName, processed, usedNames) as TIntersection
+
+    types.forEach(type => {
+      ast.params.push(parseAsTypeWithCache(schema, type, options, keyName, processed, usedNames))
+    })
+
+    log('blue', 'parser', 'Types:', [...types], 'Input:', schema, 'Output:', ast)
     return ast
   }
 
-  // Be careful to first process the intersection before processing its params,
-  // so that it gets first pick for standalone name.
-  const ast = parseAsTypeWithCache(
-    {
-      $id: schema.$id,
-      allOf: [],
-      description: schema.description,
-      title: schema.title,
-    },
-    'ALL_OF',
-    options,
-    keyName,
-    processed,
-    usedNames,
-  ) as TIntersection
-
-  ast.params = types.map(type =>
-    // We hoist description (for comment) and id/title (for standaloneName)
-    // to the parent intersection type, so we remove it from the children.
-    parseAsTypeWithCache(maybeStripNameHints(schema), type, options, keyName, processed, usedNames),
-  )
-
-  log('blue', 'parser', 'Types:', types, 'Input:', schema, 'Output:', ast)
-  return ast
+  if (types.size === 1) {
+    const type = [...types][0]
+    const ast = parseAsTypeWithCache(schema, type, options, keyName, processed, usedNames)
+    log('blue', 'parser', 'Type:', type, 'Input:', schema, 'Output:', ast)
+    return ast
+  }
+
+  throw new ReferenceError('Expected intersection schema. Please file an issue on GitHub.')
 }
 
 function parseAsTypeWithCache(
-  schema: LinkedJSONSchema,
+  schema: NormalizedJSONSchema,
   type: SchemaType,
   options: Options,
   keyName?: string,
@@ -131,7 +111,7 @@ function parseLiteral(schema: JSONSchema4Type, keyName: string | undefined): AST
 }
 
 function parseNonLiteral(
-  schema: LinkedJSONSchema,
+  schema: NormalizedJSONSchema,
   type: SchemaType,
   options: Options,
   keyName: string | undefined,
@@ -289,7 +269,9 @@ function parseNonLiteral(
         standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames, options),
         params: (schema.type as JSONSchema4TypeName[]).map(type => {
           const member: LinkedJSONSchema = {...omit(schema, '$id', 'description', 'title'), type}
-          return parse(maybeStripDefault(member as any), options, undefined, processed, usedNames)
+          maybeStripDefault(member)
+          applySchemaTyping(member)
+          return parse(member, options, undefined, processed, usedNames)
         }),
         type: 'UNION',
       }

src/types/JSONSchema.ts

@@ -70,7 +70,12 @@ export interface LinkedJSONSchema extends JSONSchema {
   not?: LinkedJSONSchema
 }
 
+export const Types = Symbol('Types')
+export const Intersection = Symbol('Intersection')
+
 export interface NormalizedJSONSchema extends LinkedJSONSchema {
+  [Intersection]?: NormalizedJSONSchema
+  [Types]: ReadonlySet<SchemaType>
   additionalItems?: boolean | NormalizedJSONSchema
   additionalProperties: boolean | NormalizedJSONSchema
   extends?: string[]

src/typesOfSchema.ts

@@ -9,26 +9,26 @@ import {isCompound, JSONSchema, SchemaType} from './types/JSONSchema'
  * types). The spec leaves it up to implementations to decide what to do with this
  * loosely-defined behavior.
  */
-export function typesOfSchema(schema: JSONSchema): readonly [SchemaType, ...SchemaType[]] {
+export function typesOfSchema(schema: JSONSchema): Set<SchemaType> {
   // tsType is an escape hatch that supercedes all other directives
   if (schema.tsType) {
-    return ['CUSTOM_TYPE']
+    return new Set(['CUSTOM_TYPE'])
   }
 
   // Collect matched types
-  const matchedTypes: SchemaType[] = []
+  const matchedTypes = new Set<SchemaType>()
   for (const [schemaType, f] of Object.entries(matchers)) {
     if (f(schema)) {
-      matchedTypes.push(schemaType as SchemaType)
+      matchedTypes.add(schemaType as SchemaType)
     }
   }
 
   // Default to an unnamed schema
-  if (!matchedTypes.length) {
-    return ['UNNAMED_SCHEMA']
+  if (!matchedTypes.size) {
+    matchedTypes.add('UNNAMED_SCHEMA')
   }
 
-  return matchedTypes as [SchemaType, ...SchemaType[]]
+  return matchedTypes
 }
 
 const matchers: Record<SchemaType, (schema: JSONSchema) => boolean> = {

src/utils.ts

@@ -331,26 +331,6 @@ export function maybeStripDefault(schema: LinkedJSONSchema): LinkedJSONSchema {
   return schema
 }
 
-/**
- * Removes the schema's `$id`, `name`, and `description` properties
- * if they exist.
- * Useful when parsing intersections.
- *
- * Mutates `schema`.
- */
-export function maybeStripNameHints(schema: JSONSchema): JSONSchema {
-  if ('$id' in schema) {
-    delete schema.$id
-  }
-  if ('description' in schema) {
-    delete schema.description
-  }
-  if ('name' in schema) {
-    delete schema.name
-  }
-  return schema
-}
-
 export function appendToDescription(existingDescription: string | undefined, ...values: string[]): string {
   if (existingDescription) {
     return `${existingDescription}\n\n${values.join('\n')}`