Extend generator to support translating oneOf to xor and implementing, also better support for anyOf and Union (#30)

* the start

* need to fix

* successful new node type

* implements discriminator and oneOf

* supporting oneOf with discriminator, anyOf in validation generation

* fix

Author: Siggy Bilstein

src/handlerbars.ts

@@ -33,7 +33,7 @@ export const createHandlebars = (jsonSchema: $Refs): typeof Handlebars => {
     return frame;
   };
 
-  [array, code, collection, comparison, date, html, i18n, inflection, markdown, math, misc, number, object, path, regex, string, url].forEach(
+  [array, code, collection, comparison, date, html, i18n, inflection, object, markdown, math, misc, number, object, path, regex, string, url].forEach(
     helper => {
       handlebars.registerHelper(helper);
     },
@@ -221,7 +221,7 @@ export const createHandlebars = (jsonSchema: $Refs): typeof Handlebars => {
 
   handlebars.log = (level, ...messages) => {
     const levels = ['debug', 'info', 'warn', 'error'];
-    const actualLevel = typeof level === 'string' ? (levels.includes(level) ? level : 'info') : levels.at(level) ?? 'info';
+    const actualLevel = typeof level === 'string' ? (levels.includes(level) ? level : 'info') : (levels.at(level) ?? 'info');
     (handlebars.logger as any)['actualLogger'][actualLevel](...messages);
   };
 

src/optimizer/converter.ts

@@ -89,6 +89,8 @@ export class Converter {
         return this.convertArray(parsedNode, parsedComponents, components);
       } else if (parsed.isUnion(parsedNode)) {
         return this.convertUnion(parsedNode, parsedComponents, components);
+      } else if (parsed.isXor(parsedNode)) {
+        return this.convertXor(parsedNode, parsedComponents, components);
       } else if (parsed.isComposite(parsedNode)) {
         return this.convertComposite(parsedNode, parsedComponents, components);
       } else if (parsed.isExclusion(parsedNode)) {
@@ -136,16 +138,37 @@ export class Converter {
     if (parsedNode.definitions.length === 1) {
       return this.convertParsedNode(parsedNode.definitions[0], parsedComponents, components);
     }
+
+    let discriminatorPropertyName: string | undefined;
+    let discriminatorMapping: Record<string, optimized.OptimizedNode> | undefined;
+
+    if ('discriminatorPropertyName' in parsedNode && parsedNode.discriminatorPropertyName) {
+      discriminatorPropertyName = parsedNode.discriminatorPropertyName;
+
+      if (parsedNode.discriminatorMapping) {
+        discriminatorMapping = {};
+        for (const [key, value] of Object.entries(parsedNode.discriminatorMapping)) {
+          discriminatorMapping[key] = this.convertParsedNode(value, parsedComponents, components);
+        }
+      }
+    }
+
     return {
       ...parsedNode,
       definitions: parsedNode.definitions.map(p => this.convertParsedNode(p, parsedComponents, components)),
+      discriminatorPropertyName,
+      discriminatorMapping,
     };
   }
 
   private convertUnion(parsedNode: parsed.Union, parsedComponents: parsed.Components, components: optimized.Components) {
     return this.compress(parsedNode, parsedComponents, components);
   }
 
+  private convertXor(parsedNode: parsed.Xor, parsedComponents: parsed.Components, components: optimized.Components) {
+    return this.compress(parsedNode, parsedComponents, components);
+  }
+
   private convertComposite(parsedNode: parsed.Composite, parsedComponents: parsed.Components, components: optimized.Components) {
     return this.compress(parsedNode, parsedComponents, components);
   }

src/optimizer/nodes/index.ts

@@ -11,6 +11,7 @@ export * from './header.js';
 export * from './array.js';
 export * from './union.js';
 export * from './composite.js';
+export * from './xor.js';
 export * from './exclusion.js';
 export * from './request.js';
 export * from './tag.js';

src/optimizer/nodes/union.ts

@@ -2,6 +2,8 @@ import { OptimizedNode } from './optimized.node.js';
 
 export interface Union extends OptimizedNode {
   definitions: OptimizedNode[];
+  discriminatorPropertyName?: string;
+  discriminatorMapping?: Record<string, OptimizedNode>;
 }
 
 export const isUnion = (value: OptimizedNode): value is Union => {

src/optimizer/nodes/xor.ts

@@ -0,0 +1,11 @@
+import { OptimizedNode } from './optimized.node.js';
+
+export interface Xor extends OptimizedNode {
+  definitions: OptimizedNode[];
+  discriminatorPropertyName?: string;
+  discriminatorMapping?: Record<string, OptimizedNode>;
+}
+
+export const isXor = (value: OptimizedNode): value is Xor => {
+  return value.type === 'xor';
+};

src/optimizer/openapi.optimizer.ts

@@ -343,7 +343,7 @@ export class OpenApiOptimizer {
             pathRegex = { ...pathRegex, [name]: definition.format ?? definition.type };
           }
         });
-      } else if (optimized.isComposite(found) || optimized.isUnion(found)) {
+      } else if (optimized.isComposite(found) || optimized.isUnion(found) || optimized.isXor(found)) {
         // todo need to recursively check the definitions
 
         found.definitions?.forEach(d => {

src/parser/openapi.parser.ts

@@ -908,13 +908,40 @@ export abstract class OpenApiParser {
 
     const definitions = oneOf.map(x => this.parseSchema(x, schema.type));
 
+    let discriminatorPropertyName: string | undefined;
+    let discriminatorMapping: Record<string, ParsedNode> | undefined;
+
+    if (schema.discriminator) {
+      discriminatorPropertyName = schema.discriminator.propertyName;
+
+      if (schema.discriminator.mapping) {
+        discriminatorMapping = {};
+        for (const [key, value] of Object.entries(schema.discriminator.mapping)) {
+          // Parse the reference string into a ParsedNode
+          const parsedValue = this.parseDiscriminatorReference(value);
+          discriminatorMapping[key] = parsedValue;
+        }
+      }
+    }
+
     return {
-      type: 'union',
+      type: 'xor',
       ...modifiers,
       definitions,
+      discriminatorPropertyName,
+      discriminatorMapping,
     };
   }
 
+  private parseDiscriminatorReference(referenceString: string): ParsedNode {
+    // Create a reference object
+    const referenceObject: ReferenceObject = {
+      $ref: referenceString,
+    };
+
+    return this.createReference(referenceObject);
+  }
+
   private parseNotObject(schema: ReferenceObject | SchemaObject, modifiers: Modifiers): Exclusion {
     return {
       type: 'exclusion',

src/parser/organizer.ts

@@ -207,6 +207,10 @@ export class Organizer {
       node.definitions.forEach(x => {
         this.traverseReferences(originalDocument, components, x);
       });
+    } else if (parsed.isXor(node)) {
+      node.definitions.forEach(x => {
+        this.traverseReferences(originalDocument, components, x);
+      });
     }
   }
 

src/parser/parsed_nodes/index.ts

@@ -7,6 +7,7 @@ export * from './primative.js';
 export * from './object.js';
 export * from './composite.js';
 export * from './union.js';
+export * from './xor.js';
 export * from './exclusion.js';
 export * from './array.js';
 export * from './link.js';

src/parser/parsed_nodes/modifiers.ts

@@ -62,7 +62,7 @@ export const compareModifiers = (a: Modifiers, b: Modifiers): boolean => {
     //a.required === b.required &&
     //a.enum === b.enum &&
     a.nullable === b.nullable &&
-    //a.discriminator === b.discriminator &&
+    a.discriminator === b.discriminator &&
     a.readOnly === b.readOnly &&
     a.writeOnly === b.writeOnly &&
     a.example === b.example &&