You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@grails.apache.org by "MartinJesusDev (via GitHub)" <gi...@apache.org> on 2026/10/16 21:28:45 UTC
[I] JSON Views: a Date inside a DTO collection ignores the configured JsonGenerator and loses milliseconds [grails-core]
MartinJesusDev opened a new issue, #16660:
URL: https://github.com/apache/grails-core/issues/16660
### Expected Behavior
The same `java.util.Date` rendered through `g.render` should use the JSON Views generator
(`grails.views.json.generator.dateFormat`, `grails.views.json.generator.timeZone`,
`grails.views.json.generator.locale`) regardless of its position in the object graph: a direct bean
property, a nested bean property, or a property of an element of a `List<DTO>`, a `DTO[]` or a raw list.
With the default configuration every date in the example below should be
`2025-10-08T07:48:46.407Z`. The JSON Views guide documents that "Values rendered with `g.render` are
written the same way" (`grails-doc/src/en/guide/theWebLayer/gson/jsonConfiguration.adoc`).
### Actual Behaviour
```groovy
class DatedItem { Date date }
class Holder {
Date direct
DatedItem item
List<DatedItem> items
DatedItem[] array
List<Object> rawItems
List<Date> dates
}
```
`grails-app/views/holder/show.gson`:
```groovy
model { Object object }
json g.render(object)
```
Output on the current 8.0.x sources with the default configuration (real values from the failing
regression test):
```json
{
"direct" : "2025-10-08T07:48:46.407Z",
"item" : {"date": "2025-10-08T07:48:46.407Z"},
"items" : [{"date": "2025-10-08T07:48:46+0000"}],
"array" : [{"date": "2025-10-08T07:48:46+0000"}],
"rawItems": [{"date": "2025-10-08T07:48:46+0000"}],
"dates" : ["2025-10-08T07:48:46.407Z"]
}
```
The elements of `items`, `array` and `rawItems` are written by Groovy's default generator
(`yyyy-MM-dd'T'HH:mm:ssZ`): the milliseconds are lost and the offset representation differs. Accepting
`+0000` in a client does not recover the lost precision. JSON object key order is irrelevant.
The same inconsistency affects three more rendering paths (all verified failing before the prepared
fix, see "Source-level explanation"):
* `g.inline(object)` writes `"direct":"2025-10-08T07:48:46+0000"`.
* A child view that `inherits` a parent and does `json g.render(object)` (inline rendering) writes
`{"foo":"bar","direct":"2025-10-08T07:48:46+0000"}` for a POGO and
`{"foo":"bar","name":"Fred","created":"2025-10-08T07:48:46+0000"}` for a domain instance.
* `hal.embedded { item(object) { created object.created } }` writes the embedded date as
`2025-10-08T07:48:46+0000` instead of `2025-10-08T07:48:46.407Z`.
### Steps To Reproduce
**A. Regression test against the Grails sources (8.0.x).** The prepared PR adds this test to
`grails-views-gson`; it fails on the current sources and passes with the fix:
```groovy
class DateTimeHelperRenderingSpec extends Specification implements JsonViewUnitTest {
void "g.render of a POGO writes a Date in a collection or array of DTOs the same way as its direct property"() {
given:
def date = Date.from(Instant.parse('2025-10-08T07:48:46.407Z'))
def holder = new CollectionDateHolder(
direct: date,
item: new DatedItem(date: date),
items: [new DatedItem(date: date)],
array: [new DatedItem(date: date)] as DatedItem[],
rawItems: [new DatedItem(date: date)],
dates: [date] as Date[])
when:
def result = render('''
model { Object object }
json g.render(object)
''', [object: holder])
then:
result.json.direct == '2025-10-08T07:48:46.407Z'
result.json.item.date == result.json.direct
result.json.items*.date == [result.json.direct]
result.json.array*.date == [result.json.direct]
result.json.rawItems*.date == [result.json.direct]
result.json.dates == [result.json.direct]
}
}
```
Result before the fix (rest of the tests in the same run printed the expected values):
```
result.json.items*.date == [result.json.direct]
| | | | | | |
| | | | | | [array:[[date:2025-10-08T07:48:46+0000]],
| | | | | | dates:[2025-10-08T07:48:46.407Z],
| | | | | | direct:2025-10-08T07:48:46.407Z,
| | | | | | item:[date:2025-10-08T07:48:46.407Z],
| | | | | | items:[[date:2025-10-08T07:48:46+0000]],
| | | | | | rawItems:[[date:2025-10-08T07:48:46+0000]]]
| | | | | | false
| | | | | 2025-10-08T07:48:46.407Z
```
**B. Standalone reproducer against published artifacts (verified on 7.2.4).** Create a directory with
three files and run `gradle --no-daemon --no-parallel --max-workers=1 reproduce` with JDK 25 and
Gradle 9.1.0. No application, database, authentication or HTTP server is required; it invokes the JSON
Views engine directly.
`settings.gradle`
```groovy
rootProject.name = 'json-view-generator-reproducer'
```
`build.gradle`
```groovy
repositories {
mavenCentral()
maven { url = uri('https://repo.grails.org/grails/restricted') }
}
configurations { probe }
dependencies {
probe platform('org.apache.grails:grails-bom:7.2.4')
probe 'org.apache.grails:grails-views-gson'
probe 'jakarta.servlet:jakarta.servlet-api'
}
tasks.register('reproduce', JavaExec) {
classpath = configurations.probe
mainClass = 'groovy.ui.GroovyMain'
args layout.projectDirectory.file('reproduce.groovy').asFile.absolutePath
}
```
`reproduce.groovy`
```groovy
package reproducer
import grails.plugin.json.view.JsonViewTemplateEngine
import groovy.json.JsonSlurper
import java.time.Instant
class Item { Date date }
class Envelope {
Date direct
Item nested
List<Item> items
}
Date date = Date.from(Instant.parse('2021-03-02T00:00:00.123Z'))
def envelope = new Envelope(direct: date, nested: new Item(date: date), items: [new Item(date: date)])
def engine = new JsonViewTemplateEngine(getClass().classLoader)
def template = engine.createTemplate('import groovy.transform.Field\n@Field Object object\njson g.render(object)')
def writer = new StringWriter()
template.make([object: envelope]).writeTo(writer)
String output = writer.toString()
println output
def result = new JsonSlurper().parseText(output)
assert result.direct == '2021-03-02T00:00:00.123Z'
assert result.nested.date == result.direct
assert result.items[0].date == result.direct : 'Collection element ignores the Views generator and loses milliseconds'
```
Verified result on 7.2.4:
```json
{"direct":"2021-03-02T00:00:00.123Z","items":[{"date":"2021-03-02T00:00:00+0000"}],"nested":{"date":"2021-03-02T00:00:00.123Z"}}
```
The assertions for the direct and nested bean dates pass; the last one fails with
`Collection element ignores the Views generator and loses milliseconds`. The non-zero Gradle exit is
the expected reproduction of the defect, not a passing regression test. DTOs deliberately have a
package: default-package classes trigger an unrelated template-name lookup error. An explicit Servlet
API dependency is required on a standalone classpath.
### Environment Information
- Operating System: Linux
- JDK Version: 25 (GraalVM CE 25.2.4+7.1 and JBR 25.0.4+1.61067)
- Groovy: 5.1.x (8.0.x sources), 4.0.33 (7.2.4)
- Gradle: 9.8.1 (repository), 9.1.0 (standalone reproducer)
### Example Application
N/A — the two self-contained reproducers above (a Spock test and a standalone Gradle project)
reproduce the issue without an application.
### Version
8.0.x (`8.0.1-SNAPSHOT` sources at `ba72113c99`). Also reproduces with the published 7.2.4 artifacts.
---
### Source-level explanation (8.0.x)
`DefaultGrailsJsonViewHelper.processSimple` (lines 429-443) handles a bean property whose generic
component type is not simple. At line 439 it constructs
`new groovy.json.StreamingJsonBuilder.StreamingJsonDelegate(out, true)` **without a generator**.
Dates inside those elements are then written with the delegate's generator, which falls back to
Groovy's default (`groovy.json.JsonOutput.DEFAULT_GENERATOR`, pattern `yyyy-MM-dd'T'HH:mm:ssZ`;
`groovy-json` 4.0.33 and 5.1.3). The neighbouring branches of the same method already use the view
generator: line 435 uses `getGenerator().toJson(...)` and the nested-bean branch at lines 451-456
receives a delegate cloned from the surrounding generator-aware delegate, which is why the direct and
nested bean dates are correct.
Changing only `grails.views.json.generator.dateFormat` cannot repair a branch that never receives the
generator. Groovy is behaving according to its defaults; JSON Views should propagate the options it
owns.
The same omission exists in the other delegate construction sites. All of them were verified failing
with a test before the prepared fix:
| Site (8.0.x) | Reachable through | Evidence |
|-----------------------------------------------|-----------------------------------------------------------------------------------|--------------|
| `DefaultGrailsJsonViewHelper:439` | `List<DTO>`, `DTO[]`, raw `List` property of a POGO | verified red |
| `DefaultGrailsJsonViewHelper:107` | `g.inline(object)` | verified red |
| `DefaultGrailsJsonViewHelper:204`, `:233` | child view that `inherits` a parent and does `json g.render(object)` (inline) | verified red |
| `DefaultHalViewHelper:551`, `:558`, `:649` | `hal.embedded { name(object) { ... } }` and `HalStreamingJsonDelegate` | verified red |
In 7.2.4 the same branch lived at helper line 445, and the neighbouring simple-element branch used
the static `JsonOutput.toJson(o)`. On 8.0.x that neighbouring branch already uses
`getGenerator().toJson(...)` (line 435), so only the delegate propagation part still matches the
7.2.4 report.
### Historical comparison
The inspected `views-json:1.2.10` sources also construct a delegate without an explicit generator in
the equivalent collection branch (helper line 420), but they use Grails' former builder, whose
`JsonOutput.java:62-77` configured the fallback as `yyyy-MM-dd'T'HH:mm:ss'Z'` in GMT. Switching to
Groovy's builder changed the fallback to `+0000` and dropped milliseconds. This is source
comparison, not a full Grails 3 runtime test; the expected precision in this report comes from the
configured Grails 7/8 generator.
### Suggested Fix
Pass the configured Views generator (`getGenerator()`) when constructing those delegates, and use it
for values that should honour generator options. Do not change Groovy's global default or perform
string replacement on serialized JSON.
### Prepared fix
A fix with regression tests is prepared and will be submitted as a PR referencing this issue
(proposed branch `fix/json-views-generator-propagation`, squash commit `Fixes #<this issue>`):
* `grails-views-gson` only; no API changes, no new dependencies, no documentation change needed
(the behaviour is already documented for `g.render`).
* Tests added: `List<DTO>`, `DTO[]`, raw `List`, `List<Date>` control, root `List<DTO>` control,
configured `dateFormat`/`timeZone`, `g.inline`, template inheritance (POGO and domain instance)
and HAL embedded callables. Each one fails before the fix and passes after it.
* Validation: `./gradlew :grails-views-gson:test` -> 274 tests, 0 failures;
`./gradlew clean aggregateViolations :grails-test-report:check --continue` -> Checkstyle, CodeNarc,
PMD, SpotBugs and REPOSITORY_CONVENTIONS reports with no violations. (The repository-wide test
phase of that command also reports pre-existing locale-dependent failures on a JVM started with
`-Duser.language=es`, in modules unrelated to this change.)
Please let me know if the scope should stay limited to the DTO collection branch only; the prepared
PR currently fixes all the sites in the table above.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@grails.apache.org.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
Re: [I] JSON Views: a Date inside a DTO collection ignores the configured JsonGenerator and loses milliseconds [grails-core]
Posted by "MartinJesusDev (via GitHub) via notifications" <no...@grails.apache.org>.
MartinJesusDev commented on issue #16660:
URL: https://github.com/apache/grails-core/issues/16660#issuecomment-6531899012
Hi @jdaugherty, a brief update: the fix with regression tests is ready to submit as a pull request (branch `fix/16660-json-views-generator`). Could you take a look when you have a moment? Thank you.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@grails.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org