feat: support default jackson subtype for unions

src/generators/java/presets/JacksonPreset.ts

@@ -1,7 +1,8 @@
 import {
   ConstrainedDictionaryModel,
   ConstrainedObjectModel,
-  ConstrainedReferenceModel
+  ConstrainedReferenceModel,
+  ConstrainedUnionModel
 } from '../../../models';
 import { JavaPreset } from '../JavaPreset';
 
@@ -111,14 +112,34 @@ ${content}`;
 
       if (model.options.discriminator) {
         const { discriminator } = model.options;
-        blocks.push(
-          renderer.renderAnnotation('JsonTypeInfo', {
-            use: 'JsonTypeInfo.Id.NAME',
-            include: 'JsonTypeInfo.As.EXISTING_PROPERTY',
-            property: `"${discriminator.discriminator}"`,
-            visible: 'true'
-          })
-        );
+        const defaultDiscriminator =
+          model.originalInput?.properties?.[discriminator.discriminator]
+            ?.default;
+
+        if (defaultDiscriminator) {
+          blocks.push(
+            renderer.renderAnnotation('JsonTypeInfo', {
+              use: 'JsonTypeInfo.Id.NAME',
+              include: 'JsonTypeInfo.As.EXISTING_PROPERTY',
+              defaultImpl: findClassNameOfSubtype(
+                model,
+                discriminator.discriminator,
+                defaultDiscriminator
+              ),
+              property: `"${discriminator.discriminator}"`,
+              visible: 'true'
+            })
+          );
+        } else {
+          blocks.push(
+            renderer.renderAnnotation('JsonTypeInfo', {
+              use: 'JsonTypeInfo.Id.NAME',
+              include: 'JsonTypeInfo.As.EXISTING_PROPERTY',
+              property: `"${discriminator.discriminator}"`,
+              visible: 'true'
+            })
+          );
+        }
 
         const types = model.union
           .map((union) => {
@@ -169,3 +190,27 @@ ${content}`;
     }
   }
 };
+
+function findClassNameOfSubtype(
+  model: ConstrainedUnionModel,
+  discriminatorPropertyName: string,
+  discriminatorValue: string
+): string {
+  for (const union of model.union) {
+    if (
+      union instanceof ConstrainedReferenceModel &&
+      union.ref instanceof ConstrainedObjectModel
+    ) {
+      const discriminatorProp = Object.values(union.ref.properties).find(
+        (model) => model.unconstrainedPropertyName === discriminatorPropertyName
+      );
+      if (
+        discriminatorProp?.property.options.const?.originalInput ===
+        discriminatorValue
+      ) {
+        return `${union.name}.class`;
+      }
+    }
+  }
+  return `${discriminatorValue}.class`;
+}

test/generators/java/presets/JacksonPreset.spec.ts

@@ -118,6 +118,111 @@ describe('JAVA_JACKSON_PRESET', () => {
       expect(models.map((model) => model.result)).toMatchSnapshot();
     });
 
+    test('handle oneOf with default with AsyncAPI discriminator with Jackson', async () => {
+      const asyncapiDoc = {
+        asyncapi: '2.6.0',
+        info: {
+          title: 'CloudEvent example',
+          version: '1.0.0'
+        },
+        channels: {
+          owner: {
+            publish: {
+              message: {
+                $ref: '#/components/messages/Owner'
+              }
+            }
+          }
+        },
+        components: {
+          messages: {
+            Owner: {
+              payload: {
+                $ref: '#/components/schemas/Owner'
+              }
+            }
+          },
+          schemas: {
+            Owner: {
+              type: 'object',
+              properties: {
+                name: {
+                  type: 'string'
+                },
+                pets: {
+                  type: 'array',
+                  items: {
+                    $ref: '#/components/schemas/Pet'
+                  }
+                }
+              }
+            },
+            Pet: {
+              title: 'Pet',
+              type: 'object',
+              discriminator: 'petType',
+              properties: {
+                petType: {
+                  type: 'string',
+                  default: 'Fish'
+                }
+              },
+              required: ['petType'],
+              oneOf: [
+                {
+                  $ref: '#/components/schemas/Fish'
+                },
+                {
+                  $ref: '#/components/schemas/Bird'
+                },
+                {
+                  $ref: '#/components/schemas/FlyingFish'
+                }
+              ]
+            },
+            Bird: {
+              title: 'Bird',
+              properties: {
+                breed: {
+                  type: String
+                }
+              },
+              allOf: [
+                {
+                  $ref: '#/components/schemas/Pet'
+                }
+              ]
+            },
+            Fish: {
+              title: 'Fish',
+              allOf: [
+                {
+                  $ref: '#/components/schemas/Pet'
+                }
+              ]
+            },
+            FlyingFish: {
+              title: 'FlyingFish',
+              type: 'object',
+              allOf: [
+                {
+                  $ref: '#/components/schemas/Fish'
+                }
+              ],
+              properties: {
+                breed: {
+                  const: 'FlyingNemo'
+                }
+              }
+            }
+          }
+        }
+      };
+
+      const models = await generator.generate(asyncapiDoc);
+      expect(models.map((model) => model.result)).toMatchSnapshot();
+    });
+
     test('handle oneOf with Swagger v2 discriminator with Jackson', async () => {
       const openapiDoc = {
         swagger: '2.0',