Invalid parent parameter provided to static inner class constructors

[G0dC0der]

This is a document in collection, exported via MongoDB Compass:

{
  "_id": {
    "$numberLong": "24"
  },
  "name": "attr",
  "storageFormat": {
    "elementFormat": {
      "elementFormat": {
        "elementFormat": {
          "datatype": "DOUBLE",
          "_class": "com.company.cms.persistence.entity.StorageFormatEntity$DataTypeEntity"
        },
        "_class": "com.company.cms.persistence.entity.StorageFormatEntity$ArrayFormatEntity"
      },
      "_class": "com.company.cms.persistence.entity.StorageFormatEntity$ArrayFormatEntity"
    },
    "_class": "com.company.cms.persistence.entity.StorageFormatEntity$ArrayFormatEntity"
  },
  "_class": "com.company.cms.persistence.entity.AttributeEntity"
}

At this point, everything looks correct. However, when I read it, storageFormat.elementFormat is null.
This is the class:

public sealed interface StorageFormatEntity {

    record DataTypeEntity(String datatype) implements StorageFormatEntity {}

    record ContentRefEntity(List<Long> templates) implements StorageFormatEntity {}

    record ArrayFormatEntity(StorageFormatEntity elementFormat) implements StorageFormatEntity {}
}

I have temporarily solved this by registering a custom read converter, but I feel like this shouldn't be necessary. I feel like this is a bug in the framework.

I am using Spring Boot 3.2.1.

[mp911de]

If you would like us to spend some time helping you to diagnose the problem, please spend some time describing it and, ideally, providing a minimal yet complete sample that reproduces the problem. Looking at the example, AttributeEntity is missing so we do not have a complete example here.
You can share it with us by pushing it to a separate repository on GitHub or by zipping it up and attaching it to this issue.

[G0dC0der]

A simple demo. Look at class DemoApplication. There is also a docker-compose file, that starta a Mongo instance.
demo.zip

package com.example.demo;

import com.example.demo.DemoApplication.Format.RecursiveFormat;
import com.example.demo.DemoApplication.Format.StaticFormat;
import java.util.Random;
import org.bson.json.JsonWriterSettings;
import org.bson.types.ObjectId;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.mapping.Document;

@SpringBootApplication
public class DemoApplication implements CommandLineRunner {

	public static void main(String[] args) {
		SpringApplication.run(DemoApplication.class, args);
	}

	@Document("attributes")
	public record Attribute(@Id ObjectId id, Format format) {}

	public sealed interface Format {
		public record RecursiveFormat(Format format) implements Format {}

		public record StaticFormat(String format) implements Format {}
	}

	@Autowired
	private MongoTemplate mongoTemplate;

	@Override
	public void run(final String... args) throws Exception {
		var id = new ObjectId();
		var attribute = new Attribute(id, new RecursiveFormat(new RecursiveFormat(new RecursiveFormat(new StaticFormat("FOO")))));

		mongoTemplate.save(attribute);
		System.out.println("Saved: " + attribute);

		var document = mongoTemplate.execute("attributes", collection -> collection.find(new org.bson.Document("_id", id)).first());
		System.out.println("Reading document as a org.bson.Document" + document.toJson(JsonWriterSettings.builder().indent(true).build()));

		var readAttribute = mongoTemplate.findById(id, Attribute.class);
		System.out.println("Reading document as Attribute: " + readAttribute);
	}
}

Logs:

Saved: Attribute[id=65c1423f0fbf892135c39397, format=RecursiveFormat[format=RecursiveFormat[format=RecursiveFormat[format=StaticFormat[format=FOO]]]]]

Reading document as a org.bson.Document{
  "_id": {
    "$oid": "65c14305757b715020f450cd"
  },
  "format": {
    "format": {
      "format": {
        "format": {
          "format": "FOO",
          "_class": "com.example.demo.DemoApplication$Format$StaticFormat"
        },
        "_class": "com.example.demo.DemoApplication$Format$RecursiveFormat"
      },
      "_class": "com.example.demo.DemoApplication$Format$RecursiveFormat"
    },
    "_class": "com.example.demo.DemoApplication$Format$RecursiveFormat"
  },
  "_class": "com.example.demo.DemoApplication$Attribute"
}

Reading document as Attribute: Attribute[id=65c1423f0fbf892135c39397, format=RecursiveFormat[format=null]]

[G0dC0der]

So, when fetching the object with mongTemplate.execute, the returned object looks perfectly fine. However, when findById is used, it does not!

[christophstrobl]

@G0dC0der thanks for the reproducer - we'll have a look.

[christophstrobl]

So apparently this is an issue when the mapping requires objects to be created via an argument constructor. Things works as expected when switching RecursiveFormat to a class having a noargs constructor.

[christophstrobl]

The issue stems from PersistentEntityParameterValueProvider which considers the constructor Parameter to belong to the parent type and then returning null for the actual value.