gorme | Global Offensive Realtime Map Editor | Map library

The problem is due to the use of the old, deprecated versio for JTS which use the com.vividsolutions package names.

Recent versions of Hibernate no longer recognize com.vividsolutions.geom.Geometry as a geometry type so fails to engage to proper (de)serialization functions.

The solution is to upgrade to JTS versions > 1.15

How can I enforce that all entity persistence operations in my Grails application happen via a GORM data services

There is no way to enforce that right now.

I've done a bunch of internet searches, pored over the GORM documentation, and even dug around in the GORM code a bit, and I can't seem to find any information about this.

We don't have support in the framework for doing that.

Since data services provide all the same CRUD functionality as GormEntityApi and dynamic finders, this seems like a reasonable thing to want to do. I feel like I must be missing something.

I don't think you are missing something. We have considered not adding the GormEntity trait to domain classes by default, but right now that happens and we don't provide a mechanism for turning that off.

Thanks to the excellent article suggested, I was able to solve the problem.

The solution was decorate the books declaration in the Author class with the @JsonManagedReference annotation and decorate the author declaration in the Book class withe the @JsonBackReference annotation.

I had the same issue, and after two days of debugging finally found a workaround.

• There is a Grails utility class called org.grails.datastore.mapping.reflect.FieldEntityAccess, apparently used to access entities fields using reflection. That class has an inner class called FieldEntityReflector. Every time a FieldEntityAccess instance is created, there is an instance of FieldEntityReflector created internally. All those instances are stored in a static map called REFLECTORS, whose keys are the entity names, apparently for performance reasons.
• During bean initialization, mongoDatastore bean creates one FieldEntityAccess for each entity, passing a DocumentPersistentEntity as constructor parameter.
• In the same way, grailsDomainClassMappingContext bean, unaware of mongoDatastore creates its own FieldEntityAccess for each entity, passing down KeyValuePersistentEntity as parameter. Those FieldEntityAccess instances and their corresponding EntityReflectors are unaware of mongo and therefore don't support mongo specific types like Point.
• Given that the REFLECTORS map keys are entity names, EntityReflectors created last for the same entity, override previously created reflectors, and are used by all EntityReflector instances.
• When grailsDomainClassMappingContext reflectors are created last, they are used when mongo tries to persist and entity and therefore throw an error.

In development mode, UrlMappingsGrailsPlugin plugin creates some beans used to allow url mappings reloading. Those beans trigger instantiation of grailsDomainClassMappingContext bean before mongoDatastore bean. As the mongo beans are created later, the error is not thrown. But, in production mode, those beans are not created, and mongoDatastore is created before grailsDomainClassMappingContext, therefore throwing the error.

1. Force grailsDomainClassMappingContext bean instantiation before mongoDatastore: I was unable to do that after several attempts, maybe because of grails bean instantiation logic.
2. Force UrlMappingsGrailsPlugin instantiation even on production mode: I prefered not to go that way due to possible permformance implications.
3. Use the static method clearReflectors of FieldEntityAccess class to clear all the reflectors after system initialization:** I decided to do that and the system started to work. I haven't tested it in depth, but was able to persist Point correctly.

In order to call the method, I created a bean depending on both grailsDomainClassMappingContext and mongoDatastore and called FieldEntityAccess.clearReflectors()

Presumably you updated from Hibernate 4 to 5 at the same time? Hibernate 5 currently has an issue where it generates foreign keys differently: https://hibernate.atlassian.net/browse/HHH-10574

I'm not sure this is the issue you're seeing, but it might be related. Even if not, it's something to be aware of.

So normally in a Unit test you test a single unit, User in this case. Because you want to test additional entities, you need to add them to the test. You can do this by implementing getDomainClassesToMock. Best is to use the DataTest trait instead of the DomainUnitTest in this situation (DomainUnitTest extends DataTest).

So your test should look like:

For grails >= 3.3.0 you can mock domain classes using new Unit Test framework features. Implement DataTest and getDomainClassesToMock():

You are getting the error because nowhere in your code are you starting a Hibernate session. There are several ways you can address this. One is you can start a session explicitly...

Long story in short

Your User.findOrSaveWhere(username:"admin", password:"password") is the problem. If you try without password:"password" your code will run considering setting the password user.password='password' while initiating new User.

The saved password in the DB is hashed and it doesn't match with your given password. So, everytime you run the app, it doesn't find matching user and tries to save a new User with same username violating the unique constraints.

Deatils -

I tried with below codes -