Blog | Grails Framework

What's Changed

For changes made in Grails 7 prior to 7.0.0, check out the following blog posts:

7.0.0 Changes:

org.apache.grails:grails-i18n has been changed to org.apache.grails.i18n:grails-i18n and is provided transitively, remove org.apache.grails:grails-i18n from your dependency list
Bump github/codeql-action from 3 to 4 @dependabot[bot] (#15135)
Take snapshot prior to mongo update then mark any changes during beforeUpdate and update events as dirty. @codeconsole (#15143)
Remove method from GradleUtils @matrei (#15126)
Update grails-publish and add organization to pom @matrei (#15138)
Add kapa.ai AI assistant widget to docs templates @jamesfredley (#15134)
Update documentation links to grails.apache.org/docs @jamesfredley (#15131)
Update release workflow to publish doc to grails-website @jamesfredley (#15128)
Use consistent ISO-8601 formatting for rendering JSON Date, Calendar, LocalDateTime, and Instant properties @codeconsole (#15121)
Centralizing Gradle Logic @jdaugherty (#15114)
Instant should persist the same way (BsonType.DATE_TIME) as LocalDateTime and Date @codeconsole (#15111)
Add additional Sitemesh -> grails-layout class and property moves/changes to docs @jamesfredley (#15112)
Docs GSP Javascript: Removed deprecated example @dauer (#15106)
15100 - remove previous optimization for older JDKs & larger projects @jdaugherty (#15104)
Update cyclonedx to 2.4.1 @matrei (#15099)
#14993 - Remove spring loaded @jdaugherty (#15096)
Update asset-pipeline and bom versions to 5.0.19 @jamesfredley (#15092)
Update asset-pipeline and bom versions to 5.0.18 @jamesfredley (#15089)
Add 'migrations' to grailsAppResourceDirs resolve duplicates @jamesfredley (#15084)
Gorm service enhancements @codeconsole (#15070)
Update spring-boot.version to 3.5.6 @jamesfredley (#15080)
Issue-15061 Grails-doc bug in render example @dauer (#15072)
Support for Gorm Entities with same name, but different packages @codeconsole (#15036)
Merge v7.0.0-RC2 & Back to snapshot @jdaugherty (#15068)
Remove additivity attribute from StackTrace logger @jamesfredley (#15066)
Add upgrade notes for hibernate.cache.region.factory_class @jamesfredley (#15063)
Issue-14172 Out Of Date Instructions For Creating A Plugin @dauer (#15062)
Revise upgrading guide for Grails 7: grails-i18n plugin @jamesfredley (#15060)
Add external references for dependency graph @jamesfredley (#15054)
Update GitHub references and default project slug for documentation @jamesfredley (#15053)
Update gradleToolingApiVersion to 8.14.3 @jamesfredley (#15047)
Update grails-publish-plugin version to 0.0.1-SNAPSHOT @jamesfredley (#15050)

🚀 Features

Remove Neo4j Forge Feature @jamesfredley (#15107)
Remove LogbackGroovy logging feature temporarily for 7.0.0 @jamesfredley (#15098)
15048 - feature: reproducible gorm service implementations @jdaugherty (#15097)
15085 - set banner in constructor so commands & scripts have it defaulted @jdaugherty (#15094)
feature: generate sboms for all published binary jar files @jdaugherty (#15087)
14977 - multiproject reloading support @jdaugherty (#15076)
feature: allow disabling micronaut configuration by the grails plugin @jdaugherty (#15069)

💡 Improvements

15079 - grails-micronaut improvements @jdaugherty (#15105)
fix(geb): minor improvements @matrei (#15103)

🐛 Bug Fixes

chore: Fix 15102 Removed traces of incubation and PPMC @sbglasius (#15115)
fix(geb): minor improvements @matrei (#15103)
fix: 13851 - move GrailsMessageSourceUtils @matrei (#15101)
Geb 8 @matrei (#15067)
fix: wrapper should only consider release types that are a higher priority than the wrapper version when packaged @jdaugherty (#15052)
fix: remove leftover grails-doc plugin declaration @matrei (#15051)
🔧 Maintenance
Test Demonstrating Mongo beforeUpdate changes are not persisted @codeconsole (#15142)
gson views date/calendar should have millisecond precision to match standard rendering @codeconsole (#15130)
Web profile jar artifact restore @jamesfredley (#15125)
Test publishing docs to /docs on apache/grails-website @jamesfredley (#15123)
First Step in optimizing GSP Performance on Grails 7. Safe small optimizations to start @davydotcom (#15109)
chore: Fix 15102 Removed traces of incubation and PPMC @sbglasius (#15115)
15048 - feature: reproducible gorm service implementations @jdaugherty (#15097)
build reproducibility & verification issues after testing 7.0.0-RC2 @jdaugherty (#15055)

Full Changelog: v7.0.0-RC2...v7.0.0

Upgrade instructions are available in the documentation.

Additional Releases

The following plugins and tools are being released alongside Grails 7.0.0:

Dependency Upgrades

In this release, we've upgraded several dependency versions, including but not limited to the following:

Asset Pipeline 5.0.19 (now cloud.wondrify.asset-pipeline)
Spring Framework 6.2.11
Spring Boot 3.5.6
See all in the grails-bom.

Generating a new Grails 7.0.0 application with Grails Forge

Try out Grails today by visiting our online application generator Grails Forge. This is the quickest and the recommended way to get started with Grails.

After installing JetBrains' IntelliJ IDEA 2025.2 or later and the Grails Plugin, the Grails Application Forge will also be available under New Project in IntelliJ IDEA.

Within your newly generated project you can access the Grails CLIs with the Grails Wrapper.

See the Types of CLI section in the documentation for details on each CLI.

grail-shell-cli

grailsw

grails-forge-cli

grailsw -t forge

Installing Grails CLIs 7.0.0 with SDKMan

Alternatively, you can quickly install Grails 7.0.0 CLIs (grails-shell-cli and grails-forge-cli) using SDKMan.

See the Types of CLI section in the documentation for details on each CLI.

If you don't have SDKMan installed, follow the instructions at SDKMan Installation Guide to set it up.
Once SDKMan is installed, open your terminal and run the following command to install Grails 7.0.0:
```
sdk install grails 7.0.0
```
You're all set! To verify the installation, run:
```
grails --version
```

The Grails Shell CLI can be accessed as:

grails

grails-shell-cli

The Grails Forge CLI can be accessed as:

grails -t forge

grails-forge-cli

Upgrading Your Existing Applications to Grails 7.0.0

If you already have a Grails application and want to upgrade to the latest version, follow these steps:

Open the project in your favorite IDE (preferably JetBrains' IntelliJ IDEA 2025.2 or later).
Update your application's gradle.properties file to specify Grails 7.0.0 as the desired version.
```
grailsVersion=7.0.0
```
Make any necessary adjustments to your application code, configuration, and dependencies to ensure compatibility with the new version. See Upgrade Guide
- remove org.apache.grails:grails-i18n from your dependency list, it has changed to org.apache.grails.i18n:grails-i18n and is provided transitively by default

Normally, Grails Core dependencies are automatically updated using the Grails Bill of Materials (BOM). However, if you have specific versions defined in your build configuration, you may need to manually update them to align with Grails 7.0.0.

By following these steps, you should be able to transition your existing Grails application to Grails 7.0.0.

Exploring Alternative Approaches

If manual dependency updates seem daunting, or you want a more streamlined approach, consider the following alternatives:

1. Use Grails Forge Website

Visit Grails Forge and generate a new Grails application with Grails 7.0.0. Compare the versions in the newly generated application with your existing one to identify any discrepancies. This can serve as a reference point for your update.

2. Automated Dependency Update Bots

Configure automated dependency update bots like Renovate or Dependabot with your source control platform (e.g., GitHub). These bots can automatically detect and update outdated dependencies in your project, including Grails dependencies, saving you time and effort in manual updates.

With these steps and alternative approaches, you should be well on your way to enjoying the exciting features and improvements in Grails 7.0.0.

Why should you try out Grails 7.0.0?

Leverage cutting-edge foundations: Built on the latest Groovy 4.0.28, Spring Framework 6.2.11, Spring Boot 3.5.6, Jakarta EE, and an optimized Asset Pipeline for seamless, modern web development.
Boost productivity with fresh enhancements: Packed with bug fixes, performance tweaks, and innovative features like containerized browser testing via Geb, external configuration integration streamlining your workflow.
Celebrate a historic milestone: As the inaugural release under Grails' new status as an Apache Top-Level Project, it underscores two decades of innovation and the vibrant open-source community's unwavering commitment.
Invest in the future: This version drives ongoing innovation, backed by an active Grails community ensuring support, updates, and evolving capabilities tailored to your needs.

Grails Release Schedule

Grails 7.0.0 Release: Officially released on October 18, 2025, as the first stable version under the Apache Software Foundation (ASF).
Grails 7.0.x Patch Releases: Scheduled at least monthly to align with Spring Boot's monthly cadence; additional releases may occur as needed for urgent fixes.
Grails 7.0.x Support Period: Full updates and maintenance available until the Spring Boot 3.5.x end-of-life on June 30, 2026.
Grails 8.0.x Development: Set to commence in late November 2025, immediately following the Spring Boot 4.0.0 general availability release.
Grails 6.x End-of-Life: Version 6.2.3 (released January 3, 2025) marks the final 6.2.x update and the last pre-ASF release, driven by the Spring Boot 2.7.x end-of-life.

Apache Grails Mailing Lists

Users Mailing List

The users mailing list will be a General purpose list for questions and discussion about Grails.
Web Archive: https://lists.apache.org/list.html?users@grails.apache.org
Subscribe: Send a blank email to users-subscribe@grails.apache.org

Dev Mailing List

The dev mailing list is focused on the framework implementation and its evolution.
Web Archive: https://lists.apache.org/list.html?dev@grails.apache.org
Subscribe: Send a blank email to dev-subscribe@grails.apache.org

When participating in mailing lists, you should never include any personally identifiable information (PII) like your address, phone number or email address, as all messages sent to these lists are publicly accessible and archived, meaning anyone can view your information. Make sure your email client does not add your signature with these items.

Thank you!

A huge thank you to our amazing community for supporting the Grails Framework over the past 20 years! We’re excited for the future and grateful for the opportunity to continue innovating and pushing Grails forward together.

Contributors

We would like to extend our heartfelt thanks to all the contributors who made Grails 7.0.0 possible.
Special thanks to:

Recent Contributors by Project:

Apache Software Foundation Press Release

Their dedication and hard work have significantly contributed to the release of Grails 7.0.0.

Join the Grails Slack Community, share your feedback, and contribute to making Grails Framework even better in the future. Happy coding!

Apache Grails Graduates to Top-Level Project at The Apache Software Foundation

James Fredley — Tue, 07 Oct 2025 00:00:00 GMT

The Apache Grails team is excited to announce that Apache Grails has officially graduated from incubation under the Apache Groovy project to become a Top-Level Project (TLP) at The Apache Software Foundation (ASF). This achievement reflects the dedication of our community and underscores the strength of the ASF's open source ecosystems.

Apache Grails is a powerful Apache Groovy-based web application framework for the Java Virtual Machine (JVM) built on top of Spring Boot. It enables rapid application development through convention-over-configuration and Don't Repeat Yourself (DRY) principles, making it ideal for productively building full-stack applications with simplicity. Similar to Ruby on Rails, Grails has a nearly 20-year history of evolution and refinement, built on Java Enterprise foundations like Spring Framework, Jakarta EE, and Hibernate.

"Becoming an ASF Top-Level Project signals the beginning of a new chapter for Apache Grails," said James Fredley, Apache Grails PMC Chair. "With ASF’s support and a thriving contributor community, we look forward to broadening adoption and advancing the project’s capabilities."

We invite the community to join us in this new chapter—contribute, provide feedback, and help shape the future of Apache Grails!

Why use Grails?

Rapid application development with high developer productivity
Full-stack web framework with everything included
DRY & Convention-Over-Configuration: Less boilerplate, sensible defaults
Gentle learning curve with Groovy for productivity
"Framework of frameworks" built on Spring Boot, Spring Framework, Jakarta EE, and Hibernate for enterprise foundations

History and Migration Journey

Work on the Grails framework began in July 2005, with the 0.1 release on March 29, 2006, and the 1.0 release on February 5, 2008. Over the years, ownership transitioned from G2One (2005-2008) to SpringSource (2008-2015), Object Computing (2015-2021), and the Grails Foundation/Unity Foundation (2021-2025), before joining the ASF in 2025. For much of its history, Grails was primarily led by single organizations.

The migration to the ASF was an 18-month process starting in late Spring 2024 alongside Grails 7 development. Motivations included shifting from single-organization dependency to a volunteer-driven model for sustainability, fostering community growth and revitalization with new energy from volunteers, aligning with open-source best practices like the Apache Way (consensus and transparency), enhancing governance through a Project Management Committee (PMC), mailing lists, and voting, and promoting vendor neutrality to encourage broader collaboration. The key steps to becoming a TLP involved forming a volunteer team, assessing project readiness, submitting an incubation proposal, ensuring the code base met ASF policy, and issuing releases under the ASF.

The development team decided to use a mono-repo approach for the Grails code base to help accelerate compliance with ASF policy. This involved merging 24+ separate GitHub repositories (that also were the result of other combination efforts) into a single code base. Each of these merges required integrating separate build systems & release processes over 100s of commits. Builds for a release went from 3+ weeks to approximately 30 minutes after this effort. The grails-core mono-repo now produces over 325 published jar files across 109 gradle projects with local build times taking anywhere between 2 and 10 minutes (depending on caching & hardware).

With the ability to release, the project turned to meeting ASF policy. The initial goal: changing our maven coordinates. All of the Grails maven coordinates had to switch to a base group of org.apache.grails. This required agreement across the community on package names since conflicts arose due to overlapping coordinates. Significant feedback was given by the community to produce more consistent and predictable coordinate name. As part of this change, a Gradle Plugin (grails-publish) was written to ease publishing our packages. This plugin is now available for any project to use.

Next, ASF security policy requires verifiable builds for projects that use GitHub actions. This required changing the Grails build to be reproducible, upstream changes to several of our dependencies (including contributions to Apache Groovy), and the ability to verify any Grails build independently. A major benefit to the community was that Grails applications can now be made reproducible as well.

The last major goal was licensing compliance. First, every source file had to changed or reviewed for its license headers. Second, 327 separate artifacts had to be reviewed to ensure we were not distributing an incompatible license. Like the mono repo merge, publishing optimizations, and verifiable builds initiatives, the dev team automated license review by adopting Software Bill of Materials for any published jar file. This ensures we stay compliant and reduces future effort to review licenses.

The final major initiative was automating our release process so that we could release more frequently. This involved developing new GitHub Actions that assisted in every step of the release process. The resulting work is the GitHub Release workflow that will enable future committers to help release Grails without specialized knowledge of our build.

Overall, the changes to Grails can be characterized as a modernization of our build system, licensing compliance, & release process that will ensure Grails survives. The changes will benefit every end Grails application and ensure that Grails is enterprise ready. Over 2,000 commits were made to the grails-core mono-repo alone. 1,247,686 lines were removed from the code base with over 2,631,372 lines changing; many of these changes were incremental to ensure a stable build as significant change was made to the code base.

Releases for grails-core included Milestone 4 (June 2025, the first ASF release), Milestone 5 (July 2025), Release Candidate 1 (August 2025), Release Candidate 2 (September 2025), with the 7.0.0 General Availability expected in October 2025. There are also numerous other releases across the Grails Spring Security plugins, Redis plugin, Quartz plugin, and other supporting projects that were moved to the ASF.

The project passed the ASF board vote on September 24, 2025, officially graduating to TLP status.

We extend our thanks to all contributors who made these advancements possible. Special mentions go to recent contributors across various Grails repositories.

Takeaways from the migration process include establishing early relationships with the ASF Infrastructure team via Slack and JIRA, leveraging incubation mentors for success, planning the end state for codebase and repositories upfront to avoid duplicated efforts, addressing challenges in migrating automated Gradle and GitHub Actions workflows (now serving as a model for Gradle-based projects at the ASF), working with the community to communicate upcoming changes, and consolidating repositories from an initial 100 down to 18 (with 9 active).

Thank you!

Contributors

We would like to extend our heartfelt thanks to all the contributors who made Grails 7 possible.
Special thanks to:

Recent Contributors by Project:

Their dedication and hard work have significantly contributed to the release of Grails 7.

Resources

About The Apache Software Foundation (ASF)

The Apache Software Foundation (ASF) is the global home for open source software, powering some of the world’s most ubiquitous software projects, including Apache Airflow, Apache Camel, Apache Cassandra, Apache Groovy, Apache HTTP Server, and Apache Kafka. Established in 1999, The ASF is at the forefront of open source innovation, setting industry standards to advance software for the public good. Learn more at https://apache.org.

For media inquiries, contact press@apache.org.

Apache Grails (Incubating) [%version] - Release Announcement

James Fredley — Thu, 11 Sep 2025 00:00:00 GMT

The Apache Grails (incubating) community is excited to announce the Milestone 7.0.0-RC2 release of the Grails Framework!
We encourage you to try this pre-release version and provide your feedback here.

Download Source Code and Binary Distributions

What's Changed

For changes made in Grails 7 prior to 7.0.0-RC2, check out the following blog posts:

7.0.0-RC2 Changes:

org.apache.grails:grails-i18n has been changed to org.apache.grails.i18n:grails-i18n and is provided transitively, remove org.apache.grails:grails-i18n from your dependency list
Remove grails-forge unused docs generation and config @jamesfredley (#15041)
Update to Asset Pipeline 5.0.16 @jdaugherty (#15040)
Formatting helpers @matrei (#15034)
Remove deprecation warning for dot notation access @jamesfredley (#15035)
Add detailed documentation for standard Grails application profiles @jamesfredley (#15018)
Bump com.gradle.common-custom-user-data-gradle-plugin from 2.2.1 to 2.3 @dependabot[bot] (#14788)
Add profile support for Gradle dependency variants @jamesfredley (#15013)
Reformat code @matrei (#14925)
Update Feature info and Gradle templates @matrei (#14994)
Hide servlet features, should be selected via --servlet instead @jamesfredley (#15005)
Bump spring-boot and byte-buddy versions @matrei (#15006)
Update documentation and links to new GitHub and docs URLs @jamesfredley (#15003)
Remove embedded-mongodb feature and references @jamesfredley (#15004)
Remove grails-forge documentation guide @jamesfredley (#15000)
Cleanup broken documentation links, update links which have changed, standardize link syntax @jamesfredley (#14988)
Remove springloaded forge feature, it only works with JDK 8 or less @jamesfredley (#14992)
Make reloading feature switch between options @jamesfredley (#14985)
Update quartz and web console versions @jamesfredley (#14981)
Update links in docs to new internal link or updated external link @jamesfredley (#14973)
Add development reloading subsection to getting started section @jamesfredley (#14969)
fix: remove ServletContext from generated and test BootStrap.groovy files @jamesfredley (#14970)
Adjust core plugins artifactids in GrailsCompilerAutoConfiguration.java @jamesfredley (#14968)
Merge 7.0.0-RC1 tag @jamesfredley (#14964)

🚀 Features

feature - #14017 - add back Micronaut support to Grails 7 with optional plugin @jdaugherty (#14953)
refactor(grails-geb): Read GebConfig.groovy to allow overriding RemoteWebDriver @JonasPammer (#14987)

🐛 Bug Fixes

Restart Geb VNC Container for each Test in a Spec to get correct recordings @JonasPammer (#14995)
Forge fixes @matrei (#15019)
grails-wrapper: Fix ClosureCompleter initialization in GradleCommand @jamesfredley (#15017)
Add .git-blame-ignore-revs @matrei (#15015)
fix: add asset-pipeline-bom to grails bom @jdaugherty (#14999)
fix: sitemesh3 rendering @jdaugherty (#14989)
Fix Typo dataStore not dataSource @lynchie14 (#14966)
fix: #14951 - make groovy extension merge for shadowJar reproducible @jdaugherty (#14952)
Issues-14899 fixes Documentation: Cleanup missing files @dauer (#14950)
fix: #14947 - class cast exception due to not using local variable @jdaugherty (#14960)

🔧 Maintenance

Explicitly type render(object) to help IntelliJ ambiguous method overloading @jdaugherty (#15031)
chore: conform to code style @matrei (#15033)
Enforce code style @matrei (#15016)
Include sources from composite builds in Groovydoc @jamesfredley (#15012)
ci: use grails-forge as base dir for dependabot @matrei (#15028)
chore(deps): bump com.gradle.common-custom-user-data-gradle-plugin from 2.2.1 to 2.3 in /grails-forge @dependabot[bot] (#15026)
chore(deps): bump com.gradle.develocity from 4.0.1 to 4.1.1 in /grails-forge @dependabot[bot] (#15025)
ci: add grails-forge dir to dependabot.yml @matrei (#15024)
chore(deps): bump com.gradle.develocity from 4.0.1 to 4.1.1 @dependabot[bot] (#15022)
Add .git-blame-ignore-revs @matrei (#15015)
Remove grails-publish plugin from build plugins @jamesfredley (#15014)
Forge publish - Add workaround so that release builds do not require signing credentials @jdaugherty (#14998)
Ensure Gradle Settings file & buildSrc/build.gradle are generated during the build Phase @jamesfredley (#14971)
chore: add versioning section to RELEASE.md and a link in README.md @cbmarcum (#14962)
fix: #14951 - make groovy extension merge for shadowJar reproducible @jdaugherty (#14952)
chore: move grails-publish gradle plugin to its own project @jdaugherty (#14937)
chore: correct wording for the voting window @matrei (#14954)

Full Changelog: v7.0.0-RC1...v7.0.0-RC2

Upgrade instructions are available in the documentation.

Additional Releases

The following plugins and tools are being released alongside Grails 7.0.0-RC2:

Grails Spring Security 7.0.0-RC2

See the release page: https://github.com/apache/grails-spring-security/releases/tag/v7.0.0-RC2

Grails Quartz 4.0.0-RC2

See the release page: https://github.com/apache/grails-quartz/releases/tag/v4.0.0-RC2

Grails Redis 5.0.0-RC2

See the release page: https://github.com/apache/grails-redis/releases/tag/v5.0.0-RC2

Grails GitHub Actions 1.0.0

See the release page: https://github.com/apache/grails-github-actions/releases/tag/v1.0.0

Initial release of actions for Gradle projects' release workflows.

Purpose
The actions being released are used in gradle projects for their release workflows to handle automated version management & documentation publishing.

Actions

deploy-github-pages action - a GitHub Action to copy documentation files to a specified documentation branch. Works by creating a subfolder named the same as the documentation branch, checking out the documentation branch to that folder, staging files, and then pushing them. Action is configured via environment variables.
export-gradle-properties action - a GitHub Action that takes a Java properties file (typically gradle.properties) and exports each property as an environment variable for use in subsequent steps of your workflow.
post-release action - a GitHub Action that handles steps necessary to close out a GitHub Release process. Including incrementing the next version & merging back to the target branch
pre-release - a GitHub action that handles any pre-release steps as part of a GitHub release process. Including the project version being set based on the specified GitHub tag and updating the associated tag to the release.

Grails Gradle Publish 0.0.1

See the release page: https://github.com/apache/incubator-grails-gradle-publish/releases/tag/v0.0.1

Dependency Upgrades

In this release, we've upgraded several dependency versions, including but not limited to the following:

Asset Pipeline 5.0.16 (now cloud.wondrify.asset-pipeline)
Spring Framework 6.2.10
Spring Boot 3.5.5
See all in the grails-bom.

Generating a new Grails 7.0.0-RC2 application with Grails Forge

Try out Grails today by visiting our online application generator Grails Forge. This is the quickest and the recommended way to get started with Grails.

After installing JetBrains' IntelliJ IDEA 2025.2 or later and the Grails Plugin, the Grails Application Forge will also be available under New Project in IntelliJ IDEA.

Within your newly generated project you can access the Grails CLIs with the Grails Wrapper.

See the Types of CLI section in the documentation for details on each CLI.

grail-shell-cli

grailsw

grails-forge-cli

grailsw -t forge

Installing Grails CLIs 7.0.0-RC2 with SDKMan

Alternatively, you can quickly install Grails 7.0.0-RC2 CLIs (grails-shell-cli and grails-forge-cli) using SDKMan.

See the Types of CLI section in the documentation for details on each CLI.

If you don't have SDKMan installed, follow the instructions at SDKMan Installation Guide to set it up.
Once SDKMan is installed, open your terminal and run the following command to install Grails 7.0.0-RC2:
```
sdk install grails 7.0.0-RC2
```
You're all set! To verify the installation, run:
```
grails --version
```

The Grails Shell CLI can be accessed as:

grails

grails-shell-cli

The Grails Forge CLI can be accessed as:

grails -t forge

grails-forge-cli

Upgrading Your Existing Applications to Grails 7.0.0-RC2

If you already have a Grails application and want to upgrade to the latest version, follow these steps:

Open the project in your favorite IDE (preferably JetBrains' IntelliJ IDEA 2025.2 or later).
Update your application's gradle.properties file to specify Grails 7.0.0-RC2 as the desired version.
```
grailsVersion=7.0.0-RC2
```
Make any necessary adjustments to your application code, configuration, and dependencies to ensure compatibility with the new version. See Upgrade Guide
- remove org.apache.grails:grails-i18n from your dependency list, it has changed to org.apache.grails.i18n:grails-i18n and is provided transitively by default

By following these steps, you should be able to transition your existing Grails application to Grails 7.0.0-RC2.

Exploring Alternative Approaches

If manual dependency updates seem daunting, or you want a more streamlined approach, consider the following alternatives:

1. Use Grails Forge Website

Visit Grails Forge and generate a new Grails application with Grails 7.0.0-RC2. Compare the versions in the newly generated application with your existing one to identify any discrepancies. This can serve as a reference point for your update.

2. Automated Dependency Update Bots

With these steps and alternative approaches, you should be well on your way to enjoying the exciting features and improvements in Grails 7.0.0-RC2.

Why should you try out Grails 7.0.0-RC2?

Help us test this major upgrade of the Grails Framework and provide feedback.
Be ready for when Grails 7 is released.

Grails 7 Release Schedule

We will continue to work on updating and fixing issues over the next few weeks.
Based on feedback, an Apache Grails RC or Final release is targeted for September 2025.

Apache Grails Mailing Lists

Users Mailing List

Dev Mailing List

Thank you!

Contributors

We would like to extend our heartfelt thanks to all the contributors who made Grails 7.0.0-RC2 possible.
Special thanks to:

Recent Contributors by Project:

Their dedication and hard work have significantly contributed to the release of Grails 7.0.0-RC2.

Join the Grails Slack Community, share your feedback, and contribute to making Grails Framework even better in the future. Happy coding!

Apache Grails (Incubating) [%version] - Release Announcement

James Fredley — Sun, 10 Aug 2025 00:00:00 GMT

The Apache Grails (incubating) community is excited to announce the Milestone 7.0.0-RC1 release of the Grails Framework!
We encourage you to try this pre-release version and provide your feedback here.

Download Source Code and Binary Distributions

What's Changed

For changes made in Grails 7 prior to 7.0.0-RC1, check out the following blog posts:

7.0.0-RC1 Changes:

Add permissions to release environments by @jdaugherty in #14795
Asset plugin forking compiler @jdaugherty (#14948)
Update base, web and rest-api profiles to more closely match Forge @jamesfredley (#14942)
#14886 - add licensing to distributed shadowJar @jdaugherty (#14945)
Add non-default, optional virtual thread feature to Forge for Java 24+ @jamesfredley (#14941)
remove: pdf publishing due to licensing issues & no longer using inside of Grails documentation @jdaugherty (#14940)
Update to spring-boot 3.5.4 & groovy 4.0.28 @jamesfredley (#14934)
feature: add grails-dependency proposal @jdaugherty (#14924)
Enhance CreateReleaseDropDownTask so it can be reused by grails-spring-security @jamesfredley (#14929)
remove old asm & AnnotationMetadataReader supporting classes; adopt SimpleMetadataReaderFactory @jdaugherty (#14922)
Set spring boot dev tools as a default feature in forge to match profiles @jamesfredley (#14921)
Use version variables + minor copy and formatting adjustments @jamesfredley (#14908)
Dependency minor/patch version updates before 7.0.0-RC1 @jamesfredley (#14909)
Fix build performance issues @jprinet (#14895)
Merge 7.0.0 m5 release tag @jamesfredley (#14907)
Enhance documentation for grails-shell vs grails-forge CLIs, plus Gra… @jamesfredley (#14906)
Add version support message for IntelliJ Grails Plugin @jamesfredley (#14905)
Update GitHub repository homepage URL @jamesfredley (#14902)
Deprecated Removals @jdaugherty (#14901)
Fix snapshot docs URL, currently only appears on snapshot docs @jamesfredley (#14900)
Restore Sitemesh3GrailsPlugin @jdaugherty (#14891)
Wrapper Improvements found by M5 Release @jdaugherty (#14896)
Fix issue reported by GitHub CodeQL @matrei (#14936)
fix: #14918 adjust the class loader used for command loading to ensure the delegating cli can find all commands @jdaugherty (#14926)
fix: #14910 - make property files reproducible by default (per day) @jdaugherty (#14919)
fix: issues found by M5 release verification @jdaugherty (#14904)
fix: #13705 - revert changes to Metadata from micronaut removal @jdaugherty (#14897)
fix: #13668 - update for SpringBoot resource split into subclass @jdaugherty (#14888)
#14930 - make views reproducible by sorting views always @jdaugherty (#14946)
build(deps): bump google-github-actions/auth from 2.1.10 to 2.1.11 @dependabot[bot] (#14939)
build(deps): bump google-github-actions/setup-gcloud from 2.1.4 to 2.1.5 @dependabot[bot] (#14938)
fix: #14910 - make property files reproducible by default (per day) @jdaugherty (#14919)
doc: #14892 - update RELEASE.md for workflow changes and grails-forge repo merge @jdaugherty (#14893)
fix: #13705 - revert changes to Metadata from micronaut removal @jdaugherty (#14897)

Full Changelog: v7.0.0-M5...v7.0.0-RC1

Upgrade instructions are available in the documentation.

Dependency Upgrades

In this release, we've upgraded several dependency versions, including but not limited to the following:

Asset Pipeline 5.0.12 (now cloud.wondrify.asset-pipeline)
Groovy 4.0.28
Spring Framework 6.2.9
Spring Boot 3.5.4
Gradle 8.14.3
See all in the grails-bom.

Generating a new Grails 7.0.0-RC1 application with Grails Forge

Try out Grails today by visiting our online application generator Grails Forge. This is the quickest and the recommended way to get started with Grails.

After installing JetBrains' IntelliJ IDEA 2025.2 or later and the Grails Plugin, the Grails Application Forge will also be available under New Project in IntelliJ IDEA.

Within your newly generated project you can access the Grails CLIs with the Grails Wrapper.

See the Types of CLI section in the documentation for details on each CLI.

grail-shell-cli

grailsw

grails-forge-cli

grailsw -t forge

Installing Grails CLIs 7.0.0-RC1 with SDKMan

Alternatively, you can quickly install Grails 7.0.0-RC1 CLIs (grails-shell-cli and grails-forge-cli) using SDKMan.

See the Types of CLI section in the documentation for details on each CLI.

If you don't have SDKMan installed, follow the instructions at SDKMan Installation Guide to set it up.
Once SDKMan is installed, open your terminal and run the following command to install Grails 7.0.0-RC1:
```
sdk install grails 7.0.0-RC1
```
You're all set! To verify the installation, run:
```
grails --version
```

The Grails Shell CLI can be accessed as:

grails

grails-shell-cli

The Grails Forge CLI can be accessed as:

grails -t forge

grails-forge-cli

Upgrading Your Existing Applications to Grails 7.0.0-RC1

If you already have a Grails application and want to upgrade to the latest version, follow these steps:

Open the project in your favorite IDE (preferably JetBrains' IntelliJ IDEA 2025.2 or later).
Update your application's gradle.properties file to specify Grails 7.0.0-RC1 as the desired version.
```
grailsVersion=7.0.0-RC1
```
Make any necessary adjustments to your application code, configuration, and dependencies to ensure compatibility with the new version. See Upgrade Guide

By following these steps, you should be able to transition your existing Grails application to Grails 7.0.0-RC1.

Exploring Alternative Approaches

If manual dependency updates seem daunting, or you want a more streamlined approach, consider the following alternatives:

1. Use Grails Forge Website

Visit Grails Forge and generate a new Grails application with Grails 7.0.0-RC1. Compare the versions in the newly generated application with your existing one to identify any discrepancies. This can serve as a reference point for your update.

2. Automated Dependency Update Bots

With these steps and alternative approaches, you should be well on your way to enjoying the exciting features and improvements in Grails 7.0.0-RC1.

Why should you try out Grails 7.0.0-RC1?

Help us test this major upgrade of the Grails Framework and provide feedback.
Be ready for when Grails 7 is released.

Grails 7 Release Schedule

We will continue to work on updating and fixing issues over the next few weeks.
Based on feedback, an Apache Grails RC or Final release is targeted for September 2025.

Apache Grails Mailing Lists

Users Mailing List

Dev Mailing List

Thank you!

Contributors

We would like to extend our heartfelt thanks to all the contributors who made Grails 7.0.0-RC1 possible.
Special thanks to:

Recent Contributors by Project:

Their dedication and hard work have significantly contributed to the release of Grails 7.0.0-RC1.

Join the Grails Slack Community, share your feedback, and contribute to making Grails Framework even better in the future. Happy coding!

Apache Grails (Incubating) [%version] - Release Announcement

James Fredley — Tue, 15 Jul 2025 00:00:00 GMT

The Apache Grails (incubating) community is excited to announce the Milestone 7.0.0-M5 release of the Grails Framework!
We encourage you to try this pre-release version and provide your feedback here.

Download Source Code and Binary Distributions

What's Changed

For changes made in Grails 7 prior to 7.0.0-M5, check out the following blog posts:

7.0.0-M5 Changes:

Add permissions to release environments by @jdaugherty in #14795
Force update asf.yaml by @jdaugherty in #14796
explicitly add jdaugherty as approver by @jdaugherty in #14797
back to snapshot by @jdaugherty in #14800
Add add-license scripts for .raw, .java and .groovy by @jamesfredley in #14794
Fixes found as part of the second attempt at M2 by @jdaugherty in #14782
Verify build explanation and minor fix by @sbglasius in #14781
initial attempt at GitHub -> Mailing List notifications by @jamesfredley in #14784
Update Geb documentation changes in Breaking Changes Section by @jamesfredley in #14793
Update grails-forge - google cloud run deploy documentation by @jamesfredley in #14803
Unnest the snapshot zip uploaded to workflow results by @jamesfredley in #14808
Gradle deprecations by @jdaugherty in #14805
Update grails-static-website section on RELEASE.md by @jamesfredley in #14807
Support specifying the publication name so that gradle plugins can be published by @jdaugherty in #14812
Use developmentOnly Gradle configuration scope for webjars by @jamesfredley in #14811
Rework mainClass gradle find logic by @jdaugherty in #14816
fix: #14818 - ensure plugin is the base for web-plugin by @jdaugherty in #14819
Fixing Issue #14173 – Update grails Command Documentation for Grails 7 by @irllyliketoast in #14809
Update to new asset pipeline coordinates by @jdaugherty in #14813
fix: update grails-docs coords in GrailsDocGradlePlugin by @matrei in #14826
Support not adding components from the grails publish plugin by @jdaugherty in #14827
fix: scope webjars as testAndDevelopmentOnly by @jamesfredley in #14829
Update to Spring Boot 3.5.3 which uses Groovy 4.0.27 by @jamesfredley in #14824
database-migration mapped to grails-data-hibernate5-dbmigration by @jamesfredley in #14831
#14832 - support findMainTask caching with plugins & boot tasks in the task graph by @jdaugherty in #14833
Add Documentation: Tomcat 10.1.42 multipart/form-data part count and header size limit by @jamesfredley in #14838
chore(tests): move tests to the correct module by @matrei in #14839
Merge grails-forge into grails-core by @jdaugherty in #14836
Replace google analytics with Matomo, analytics.apache.org by @jamesfredley in #14842
Correct dependency to grails-codecs-core by @matrei in #14844
chore: update to 5.0.12 for the asset pipeline by @jdaugherty in #14879
Fix spelling by @jdaugherty in #14881
fix: #14854 - remove duplicate repo definition (restricted contains maven central) by @jdaugherty in #14882
chore: #14779 - add better instructions on how to build & use the source distribution by @jdaugherty in #14880
chore: #14877 - add DISCLAIMER, LICENSE, & NOTICE files to jar files by @jdaugherty in #14878
Various Cleanup prior to Sitemesh 2 revert by @jdaugherty in #14876
fix: #14090 - fix baseUrl returning the wrong result when forwardPort is null by @jdaugherty in #14884
Revert to Sitemesh 2 for Grails 7 by @jdaugherty in #14875
Issue #14748 - upgrade notes for gradle plugin / task changes by @jdaugherty in #14883
#14316 Use local repo commands instead of the github api for Release Drop Down population by @JudeRV in #14834

Full Changelog: v7.0.0-M4...v7.0.0-M5

Upgrade instructions are available in the documentation.

Dependency Upgrades

In this release, we've upgraded several dependency versions, including but not limited to the following:

Asset Pipeline 5.0.12 (now cloud.wondrify.asset-pipeline)
Groovy 4.0.27
Spring Framework 6.2.8
Spring Boot 3.5.3
Gradle 8.14.2
See all in the grails-bom.

Generating a new Grails 7.0.0-M5 application with Grails Forge

Try out Grails today by visiting our online application generator Grails Forge. This is the quickest and the recommended way to get started with Grails.

After installing the JetBrains' IntelliJ IDEA Grails Plugin, the Grails Application Forge will also be available under New Project in IntelliJ IDEA.

Within your newly generated project you can access the Grails CLIs with the grails wrapper

See Types of CLI for details on each CLI

grail-shell-cli

grailsw

grails-forge-cli

grailsw -t forge

Installing Grails CLIs 7.0.0-M5 with SDKMan

Alternatively, you can quickly install Grails 7.0.0-M5 CLIs (grails-shell-cli and grails-forge-cli) using SDKMan.

See Types of CLI for details on each CLI

If you don't have SDKMan installed, follow the instructions at SDKMan Installation Guide to set it up.
Once SDKMan is installed, open your terminal and run the following command to install Grails 7.0.0-M5:
```
sdk install grails 7.0.0-M5
```
You're all set! To verify the installation, run:
```
grails --version
```

The Grails Shell CLI can be accessed as:

grails

grails-shell-cli

The Grails Forge CLI can be accessed as:

grails -t forge

grails-forge-cli

Upgrading Your Existing Applications to Grails 7.0.0-M5

If you already have a Grails application and want to upgrade to the latest version, follow these steps:

Open the project in your favorite IDE (preferably JetBrains' IntelliJ IDEA).
Update your application's gradle.properties file to specify Grails 7.0.0-M5 as the desired version.
```
grailsVersion=7.0.0-M5
```
Make any necessary adjustments to your application code, configuration, and dependencies to ensure compatibility with the new version. See Upgrade Guide

By following these steps, you should be able to transition your existing Grails application to Grails 7.0.0-M5.

Exploring Alternative Approaches

If manual dependency updates seem daunting, or you want a more streamlined approach, consider the following alternatives:

1. Use Grails Forge Website

Visit Grails Forge and generate a new Grails application with Grails 7.0.0-M5. Compare the versions in the newly generated application with your existing one to identify any discrepancies. This can serve as a reference point for your update.

2. Automated Dependency Update Bots

With these steps and alternative approaches, you should be well on your way to enjoying the exciting features and improvements in Grails 7.0.0-M5.

Why should you try out Grails 7.0.0-M5?

Help us test this major upgrade of the Grails Framework and provide feedback.
Be ready for when Grails 7 is released.

Grails 7 Release Schedule

We will continue to work on updating and fixing issues over the next few weeks.
Based on feedback, an Apache Grails RC release is targeted for July/August 2025.

Apache Grails Mailing Lists

Users Mailing List

Dev Mailing List

Thank you!

A huge thank you to our amazing community for supporting the Grails Framework over the past 19 years! We’re excited for the future and grateful for the opportunity to continue innovating and pushing Grails forward together.

Contributors

We would like to extend our heartfelt thanks to all the contributors who made Grails 7.0.0-M5 possible.
Special thanks to:

Recent Contributors by Project:

Their dedication and hard work have significantly contributed to the release of Grails 7.0.0-M5.

Join the Grails Slack Community, share your feedback, and contribute to making Grails Framework even better in the future. Happy coding!

Apache Grails (Incubating) 7.0.0-M4 - Release Announcement

James Fredley — Tue, 10 Jun 2025 00:00:00 GMT

The Apache Grails (incubating) community is excited for the release of Grails Framework 7.0.0-M4.
We encourage you to try this pre-release and provide your feedback here.

Download Source Code and Binary Distributions

Users Mailing List

Dev Mailing List

What's Changed

For changes made in Grails 7 prior to 7.0.0-M4, check out the Grails 7.0.0-M1 Release Blog Post and Grails 7.0.0-M3 Release Blog Post

Apache Grails (incubating) 7.0.0-M4 is the first release for Grails under the Apache Software Foundation (ASF). This release focuses first on meeting the requirements of the ASF & improving the developer experience of Grails itself & Grails Applications. As part of this transition, the developers moved to a mono repository, reworked the way the various Grails CLIs work, modernized its build system, modernized the various Grails Gradle Tasks, modernized the various Grails Gradle Plugins, worked towards reproducible builds, added license headers to our source code, and changed the maven coordinates of all Grails Artifacts.

With the release of Grails 7.0.0-M4, we have:

PR #14750 - support non-persistent super classes for @Autotimestamp
Issue #14745 - remove deprecated doc method on Grails Plugins
Issue #14745 - remove duplicate grails.factories & grails-plugin.xml files now that AST generation is working correctly
Issue #14745 - switch to Spring Boot 3.5.0 with Spring Framework 6.2.7 due to bug (https://github.com/spring-projects/spring-framework/issues/34796)
Issue #14745 - change the grails-gradle-model to export Groovy 3 due to Gradle Task isolation in later versions of Gradle
Issue #14745 - rework the FindMainTask to correctly set the main Application class on BootWar, BootJar, & BootRun
Issue #14745 - remove org.grails.plugins.CodecGrailsPlugin; use org.grails.plugins.codecs.CodecsGrailsPlugin instead
Issue #14745 - remove the remaining pathingJar task functions
Issue #14745 - fix a databinding scenario in DataBindingUtils to lookup a domain object
PR #14749 - retire Mongo 5.0 & 6.0 test pipelines since those versions are end of support
PR #14746 - switch to asset-pipeline-gradle 5.0.9
PR #14743 - remove redundant buildScript from test projects
Issue #14706 - rework grailsw to be usable independently of SDKMAN installs
Issue #14706 - rework grails-shell-cli to be usable independently of SDKMAN installs
Issue #14706 - rework the command cli to support a grailsw that can self-update either forge or legacy shell cli
Issue #14706 - distribute a delegating CLI that can call either forge or the legacy shell cli
Issue #14706 - rework the legacy shell cli to correctly find profiles
Issue #14706 - rework both grailsw & grails-shell-cli to be testable outside of releases
Issue #14679 - generate reproducible groovydoc jars
Issue #14679 - fix profile compilation to generate reproducible jars
Issue #14679 - ensure groovydoc is used instead of javadoc for documentation jars
PR #14709 - switch to Gradle 8.14
PR #14678 - add support for external config locations, by incorporating the external-config plugin into Grails core
Refactor grails into a mono repo (grails-views, gsp, data mapping, geb, etc are all merged into core now)
As part of the mono repo transition, several Deprecated classes were removed from the views project; see the upgrade guide for the details.
Issue #14679 - refactor grails build to be parallel & lazy
Issue #14679 - change all Grails gradle tasks to support Caching where appropriate and support lazy style configuration
Issue #14679 - Redesign the Grails Data TCK to support modern versions of Java
Issue #14679 - Support consistent property dates in generated property files when SOURCE_DATE_EPOCH is set
Issue #14679 - Make grails.factories generation reproducible
Issue #14679 - Refactor Grails AST Transformations to take advantage of Groovy's TransformWithPriority and enforce transforms always run in the order defined by the class GroovyTransformOrder
Issue #14679 - Remove manifest attributes that could vary on the Grails jars (Built-By, Created-By etc)
Issue #14679 - Fix sourcejar creation to not contain duplicates
Issue #14679 - Fix javadoc jars to be generated based on groovydoc & to not contain duplicates
Issue #14679 - Change AST transforms to be reproducible by adopting determined ordering collections
Issue #14679 - Configure Grails jars per Gradle's reproducibility requirements (fixed permissions, reproducible file order, etc)
Issue #13850 - introduce grails-common to share common code between Grails Data Mapping & Grails-Core
Issue #14679 - add scripts to confirm reproducibility of Grails; currently 14 of 290 jars are reproducible
Issue #14679 - make TagLib lookups reproducible
PR #14671 - switch to webjars for test css/js assets instead of checked in files
The Grails Gradle plugin had a bug that caused plugin resolution issues that was fixed after the last milestone.
Rework the grails bom to generate valid Gradle modules, be easier to maintain, and valid pom files. Enhance the documentation process to parse the bom & generate the published versions in the grails doc.

And in addition to all of this:

We changed all coordinates of Grails to be org.apache.grails based. See https://github.com/apache/grails-core/blob/7.0.x/RENAME.md for how we mapped these libraries. There is also a script documented in the upgrade guide to assist in upgrading.
Consolidated main Grails projects into grails-core git monorepository to drastically speed up development, testing and the release process
Significant test fixes
Significant documentation updates & changes
Addition of license headers to Grails Source
Addition of NOTICE to Grails Source
Created https://repo.grails.org/grails/restricted/ to replace https://repo.grails.org/grails/core longer term. This virtual repo's scope is significantly reduced to help reduce the chance of using outdated libraries.

Upgrade instructions are available in the documentation.

Dependency Upgrades

In this release, we've upgraded several dependency versions, including but not limited to the following:

Asset Pipeline 5.0.9
Groovy 4.0.27
Spring Framework 6.2.7
Spring Boot 3.5.0
Gradle 8.14
Spock 2.3-groovy-4.0
See all in the grails-bom.

Installing Grails 7.0.0-M4

Try out Grails 7.0.0-M4 today by visiting the online app creator * Grails Forge. Alternatively, you can quickly install Grails 7.0.0-M4 using the SDKMan.

If you don't have SDKMan installed, follow the instructions at SDKMan Installation Guide to set it up.
Once SDKMan is installed, open your terminal and run the following command to install Grails 7.0.0-M4:
```
sdk install grails 7.0.0-M4
```
You're all set! To verify the installation, run:
```
grails --version
```

Upgrading Your Existing Applications to Grails 7.0.0-M4

If you already have a Grails application and want to upgrade to the latest version, follow these steps:

Open the project in your favorite IDE (preferably JetBrains' IntelliJ IDEA).

Update your application's gradle.properties file to specify Grails 7.0.0-M4 as the desired version.

grailsVersion=7.0.0-M4
# The Grails Gradle Plugin version is now available in the BOM
# and can be omitted if your project adds the Grails BOM to the
# buildscript dependencies.
grailsGradlePluginVersion=7.0.0-M4
# Temporary for 7.0.0-M4 to force the latest version
groovy.version=4.0.27

Make any necessary adjustments to your application code, configuration, and dependencies to ensure compatibility with the new version. See https://grails.apache.org/docs/7.0.0-M4/guide/upgrading.html#upgrading60x.

By following these steps, you should be able to transition your existing Grails application to Grails 7.0.0-M4.

Exploring Alternative Approaches

If manual dependency updates seem daunting, or you want a more streamlined approach, consider the following alternatives:

1. Use Grails Forge Website

Visit Grails Forge and generate a new Grails application with Grails 7.0.0-M4. Compare the versions in the newly generated application with your existing one to identify any discrepancies. This can serve as a reference point for your update.

2. Automated Dependency Update Bots

With these steps and alternative approaches, you should be well on your way to enjoying the exciting features and improvements in Grails 7.0.0-M4. Happy coding!

Why should you try out Grails 7.0.0-M4?

Help us test this major upgrade of the Grails Framework and provide feedback.
Be ready for when Grails 7 is released.

Grails 7 Release Schedule

We will continue to work on updating and fixing issues over the next few weeks.
Based on feedback, an Apache Grails RC release is targeted for July 2025.

Thank you!

Contributors

We would like to extend our heartfelt thanks to all the contributors who made Grails 7.0.0-M4 possible.
Special thanks to:

Their dedication and hard work have significantly contributed to the release of Grails 7.0.0-M4.

Join the Grails Slack Community, share your feedback, and contribute to making Grails Framework even better in the future. Happy coding!

Grails 7.0.0-M3 - Release Announcement

James Fredley — Wed, 05 Mar 2025 00:00:00 GMT

The Grails Foundation is excited for the release of Grails Framework 7.0.0-M3.
We encourage you to try this pre-release and provide your feedback here.

The next milestone is planned to be released under the Apache Software Foundation as Apache Grails 7.0.0-M4.

NOTE: Due to a release problem, 7.0.0-M2 was skipped.

Mailing Lists Changes

As we transition to Apache more communications will occur on our new Apache mailing lists.

Users Mailing List

Dev Mailing List

When participating in Apache mailing lists, you should never include any personally identifiable information (PII) like your address, phone number or email address, as all messages sent to these lists are publicly accessible and archived, meaning anyone can view your information. Make sure your email client does not add your signature with these items.

What's Changed

For changes made in Grails 7 prior to 7.0.0-M3, check out the Grails 7.0.0-M1 Release Blog Post

With the release of Grails 7.0.0-M3, we have:

Consolidated several main/core Git repositories/Gradle projects to drastically reduce the time to publish a release. This resulted in the version of many dependencies changing and in some cases skipping major versions to match with the consolidated project. The old project Git repository default branch readme has been updated to point to the new location. Existing issues and PRs have been migrated when possible.
Consolidated 10 active profiles into a single Git repository/Gradle Project.
Consolidated 6 Spring Security plugins into the Spring Security Core Git repository.
Updated the Web and Base Grails profiles to generate runnable Grails 7 applications.
Changed so that hibernate-ehcache is no longer provided by the hibernate5 plugin. See details
Fixed documentation (asciidoc, groovydoc & javadoc) generation and publishing across many projects.
Ensured tests run during build and CI across many projects.
Updated ContainerGebSpec in geb with:
- Cross-platform file input support.
- IDE hints and auto-completion of Browser.*, Page.* and WebDriver.pageSource methods.
- Recycling of the recording container.
- Delegation to the current page object.
- Inclusion of the ScreenshotReporter by default.
- Fix of log message for reports directory.
Updated grails-gradle-plugin with:
- End-to-end tests.
- Fix of configScript handling.
- Inclusion of testFixtures in version resolving for POM generation in org.grails.grails-publish.
- Fix to include AST sources in javadoc and source jars.
- Fix to org.grails.grails-publish to ensure sources and javadoc are published by default.
- Changes and standardization of profile task names so they can be used with the Java Gradle Plugin.
- Changes to not require Java or Groovy Gradle Plugins for profile publishing.
- Fix of profile publishing to support the Java Gradle Plugin.
- Consolidation of profiles into a single Gradle multi-project build.
Updated database-migration-plugin with:
- Move to gorm-hibernate5 project.
- Exclusion of liquibase-commercial to prevent it from being exported.
- Loading of migrations from embedded jars (plugins).
- Allowing the loading of classpath resources for sqlFile changesets.
Replaced tomcat-jdbc with HikariCP in default generated applications from grails-shell CLI and grails-forge CLI.
Updated asset-pipeline to resolve missing graalvm asset compiler dependencies for bootRun, unit test and integration tests.
Leveraged grails-bom versions wherever possible to simplify updates across the projects.
Consolidated any versions not set by grails-bom in gradle.properties across projects.
Allowed disabling of AutoTimestamp on insertion event if values are not null.
Allowed customization of AutoTimestamp dateCreated and lastUpdated properties.
Added GSP Pagination support for Bootstrap 5.
Fixed configuration loading in the quartz plugin.
Fixed an error in grails-bom with handling inherited BOMs from spring-boot-dependencies.

Dependency Upgrades

In this release, we've upgraded several dependency versions, including but not limited to the following:

Asset Pipeline 5.0.8
Groovy 4.0.25
Jna 5.16.0
MongoDB driver: 5.3.1
Slf4j 2.0.16
Spring Boot 3.4.2
Spring Framework 6.2.2
See all in the grails-bom.

As part of the Grails 7.0.0-M3 release we have also released milestones of the following:

org.grails.plugins:async:7.0.0-M3
org.grails.plugins:audit-logging:6.0.0-M4
org.grails.plugins:cache:8.0.0-M3
org.grails.plugins:converters:7.0.0-M3
org.grails.plugins:database-migration:9.0.0-M3
org.grails.plugins:events:7.0.0-M3
org.grails.plugins:fields:6.0.0-M3
org.grails.plugins:geb:5.0.0-M3
org.grails.plugins:grails-redis:5.0.0-M3
org.grails.plugins:grails-web-console:7.0.0-M2
org.grails.plugins:gsp:7.0.0-M3
org.grails.plugins:hibernate5:9.0.0-M3
org.grails.plugins:mongodb:9.0.0-M3
org.grails.plugins:quartz:4.0.0-M2
org.grails.plugins:scaffolding:6.0.0-M3
org.grails.plugins:spring-security-acl:7.0.0-M3
org.grails.plugins:spring-security-cas:7.0.0-M3
org.grails.plugins:spring-security-core:7.0.0-M3
org.grails.plugins:spring-security-ldap:7.0.0-M3
org.grails.plugins:spring-security-oauth2:7.0.0-M3
org.grails.plugins:spring-security-rest:7.0.0-M3
org.grails.plugins:spring-security-rest-gorm:7.0.0-M3
org.grails.plugins:spring-security-rest-grailscache:7.0.0-M3
org.grails.plugins:spring-security-rest-memcached:7.0.0-M3
org.grails.plugins:spring-security-rest-redis:7.0.0-M3
org.grails.plugins:spring-security-rest-testapp-profile:7.0.0-M3
org.grails.plugins:spring-security-ui:7.0.0-M3
org.grails.plugins:views-gradle:4.0.0-M3
org.grails.plugins:views-json:4.0.0-M3
org.grails.plugins:views-json-templates:9.0.0-M3
org.grails.plugins:views-markup:4.0.0-M3
org.grails.profiles:angular:10.0.2
org.grails.profiles:base:10.0.2
org.grails.profiles:plugin:10.0.2
org.grails.profiles:profile:10.0.2
org.grails.profiles:react:10.0.2
org.grails.profiles:rest-api:10.0.2
org.grails.profiles:rest-api-plugin:10.0.2
org.grails.profiles:vue:10.0.2
org.grails.profiles:web:10.0.2
org.grails.profiles:web-plugin:10.0.2
org.grails:grails-async:7.0.0-M3
org.grails:grails-async-gpars:7.0.0-M3
org.grails:grails-async-rxjava:7.0.0-M3
org.grails:grails-async-rxjava2:7.0.0-M3
org.grails:grails-bootstrap:7.0.0-M3
org.grails:grails-codecs:7.0.0-M3
org.grails:grails-console:7.0.0-M3
org.grails:grails-core:7.0.0-M3
org.grails:grails-databinding:7.0.0-M3
org.grails:grails-datastore-async:9.0.0-M3
org.grails:grails-datastore-core:9.0.0-M3
org.grails:grails-datastore-gorm:9.0.0-M3
org.grails:grails-datastore-gorm-async:9.0.0-M3
org.grails:grails-datastore-gorm-hibernate5:9.0.0-M3
org.grails:grails-datastore-gorm-mongodb:9.0.0-M3
org.grails:grails-datastore-gorm-rx:9.0.0-M3
org.grails:grails-datastore-gorm-support:9.0.0-M3
org.grails:grails-datastore-gorm-tck:9.0.0-M3
org.grails:grails-datastore-gorm-test:9.0.0-M3
org.grails:grails-datastore-gorm-validation:9.0.0-M3
org.grails:grails-datastore-web:9.0.0-M3
org.grails:grails-dependencies:7.0.0-M3
org.grails:grails-docs:7.0.0-M3
org.grails:grails-encoder:7.0.0-M3
org.grails:grails-events-gpars:7.0.0-M3
org.grails:grails-events-rxjava:7.0.0-M3
org.grails:grails-events-rxjava2:7.0.0-M3
org.grails:grails-gorm-testing-support:9.0.0-M3
org.grails:grails-gradle-model:7.0.0-M3
org.grails:grails-gradle-plugin:7.0.0-M4
org.grails:grails-gsp:7.0.0-M3
org.grails:grails-logging:7.0.0-M3
org.grails:grails-plugin-codecs:7.0.0-M3
org.grails:grails-plugin-controllers:7.0.0-M3
org.grails:grails-plugin-databinding:7.0.0-M3
org.grails:grails-plugin-datasource:7.0.0-M3
org.grails:grails-plugin-domain-class:7.0.0-M3
org.grails:grails-plugin-i18n:7.0.0-M3
org.grails:grails-plugin-interceptors:7.0.0-M3
org.grails:grails-plugin-mimetypes:7.0.0-M3
org.grails:grails-plugin-rest:7.0.0-M3
org.grails:grails-plugin-services:7.0.0-M3
org.grails:grails-plugin-url-mappings:7.0.0-M3
org.grails:grails-plugin-validation:7.0.0-M3
org.grails:grails-shell:7.0.0-M3
org.grails:grails-spring:7.0.0-M3
org.grails:grails-test:7.0.0-M3
org.grails:grails-testing-support:7.0.0-M3
org.grails:grails-test-suite-base:7.0.0-M3
org.grails:grails-test-suite-persistence:7.0.0-M3
org.grails:grails-test-suite-uber:7.0.0-M3
org.grails:grails-test-suite-web:7.0.0-M3
org.grails:grails-web:7.0.0-M3
org.grails:grails-web-boot:7.0.0-M3
org.grails:grails-web-common:7.0.0-M3
org.grails:grails-web-databinding:7.0.0-M3
org.grails:grails-web-gsp:7.0.0-M3
org.grails:grails-web-mvc:7.0.0-M3
org.grails:grails-web-taglib:7.0.0-M3
org.grails:grails-web-testing-support:7.0.0-M3
org.grails:grails-web-url-mappings:7.0.0-M3
org.grails:grails7-wrapper:6.0.0
org.grails:views-json-testing-support:4.0.0-M3

Installing Grails 7.0.0-M3

Try out Grails 7.0.0-M3 today by visiting the online app creator * Grails Forge. Alternatively, you can quickly install Grails 7.0.0-M3 using the SDKMan.

If you don't have SDKMan installed, follow the instructions at SDKMan Installation Guide to set it up.
Once SDKMan is installed, open your terminal and run the following command to install Grails 7.0.0-M3:
```
sdk install grails 7.0.0-M3
```
You're all set! To verify the installation, run:
```
grails --version
```

Upgrading Your Existing Applications to Grails 7.0.0-M3

If you already have a Grails application and want to upgrade to the latest version, follow these steps:

Open the project in your favorite IDE (preferably JetBrains' IntelliJ IDEA).

Update your application's gradle.properties file to specify Grails 7.0.0-M3 as the desired version.

grailsVersion=7.0.0-M3
# The Grails Gradle Plugin version is now available in the BOM
# and can be omitted if your project adds the Grails BOM to the
# buildscript dependencies.
grailsGradlePluginVersion=7.0.0-M4

Make any necessary adjustments to your application code, configuration, and dependencies to ensure compatibility with the new version. See https://grails.apache.org/docs/7.0.0-M3/guide/upgrading.html#upgrading60x.

By following these steps, you should be able to transition your existing Grails application to Grails 7.0.0-M3.

Exploring Alternative Approaches

If manual dependency updates seem daunting, or you want a more streamlined approach, consider the following alternatives:

1. Use Grails Forge Website

Visit Grails Forge and generate a new Grails application with Grails 7.0.0-M3. Compare the versions in the newly generated application with your existing one to identify any discrepancies. This can serve as a reference point for your update.

2. Automated Dependency Update Bots

With these steps and alternative approaches, you should be well on your way to enjoying the exciting features and improvements in Grails 7.0.0-M3. Happy coding!

Why should you try out Grails 7.0.0-M3?

Help us test this major upgrade of the Grails Framework and provide feedback.
Be ready for when Grails 7 is released.

Grails 7 Release Schedule

We will continue to work on updating and fixing issues over the next few weeks.
Apache Grails 7.0.0-M4 will be released thereafter under the Apache Software Foundation.
Based on feedback, an Apache Grails final milestone or RC release is targeted for April 2025.

Thank you!

Contributors

We would like to extend our heartfelt thanks to all the contributors who made Grails 7.0.0-M3 possible.
Special thanks to:

Their dedication and hard work have significantly contributed to the release of Grails 7.0.0-M3.

Join the Grails Slack Community, share your feedback, and contribute to making Grails Framework even better in the future. Happy coding!

Introducing Grails Framework 6.2.3 Release

James Daugherty — Fri, 03 Jan 2025 00:00:00 GMT

The Grails Foundation is excited to announce the release of Grails framework 6.2.3. This latest version delivers a key bug fix.

Bug Fixes and Improvements

Grails 6.2.3 addresses a critical bug fixes:

Fixes an edge cases that causes a cast class exception when inherited commands are used as an action parameter.

Dependency Upgrades

Keeping up with the latest dependencies is crucial for the health of any framework. In this release, we have upgraded various dependencies to their latest versions, including but not limited to the following:

org.grails:grails-gradle-plugin to version 6.2.4
org.apache.tomcat:tomcat-jdbc to version 9.0.98
org.apache.tomcat.embed:tomcat-embed-core to version 9.0.98

These upgrades ensure that Grails 6.2.3 remains compatible with the latest libraries and tools, providing developers with a robust and reliable environment. We recommend checking out the GitHub release page for more information.

Installing Grails 6.2.3

You can get started with Grails 6.2.3 today by visiting our official website. Alternatively, you can quickly install Grails 6.2.3 using the SDKMan.

If you don't have SDKMan installed, follow the instructions at SDKMan Installation Guide to set it up.
Once SDKMan is installed, open your terminal and run the following command to install Grails 6.2.3:
```
sdk install grails 6.2.3
```
You're all set! To verify the installation, run:
```
grails --version
```

Upgrading Your Existing Applications to Grails 6.2.3

If you already have a Grails application and want to upgrade to the latest version, follow these steps:

Open the project in your favorite IDE (preferably JetBrains' IntelliJ IDEA).
Update your application's gradle.propreties file to specify Grails 6.2.3 as the desired version.
```
grailsVersion=6.2.3
grailsGradlePluginVersion=6.2.4
```
Make any necessary adjustments to your application code, configuration, and dependencies to ensure compatibility with the new version.

By following these steps, you can smoothly transition your existing Grails application to the exciting Grails 6.2.3.

Exploring Alternative Approaches

If manual dependency updates seem daunting, or you want a more streamlined approach, consider the following alternatives:

1. Use Grails Forge Website

Visit https://start.grails.org and generate a new Grails application with Grails 6.2.3. Compare the versions in the newly generated application with your existing one to identify any discrepancies. This can serve as a reference point for your update.

2. Automated Dependency Update Bots

With these steps and alternative approaches, you should be well on your way to enjoying the exciting features and improvements in Grails 6.2.3. Happy coding!

Join the Grails Slack community, share your feedback, and contribute to making Grails framework even better in the future. Happy coding!

James Fredley Named 2025 Grails® Rock Star

Jeff Scott Brown — Thu, 02 Jan 2025 00:00:00 GMT

Happy New Year!

The Grails Foundation is recognizing and celebrating great leadership and stewardship from James Fredley.

Thank You James Fredley!

The Grails Foundation and Object Computing have been supporting the Grails community, with a special focus on Grails 6.2.x and the upcoming Grails 7 release expected in Q1 2025. This new release will streamline many aspects of the framework, update dependencies, and introduce exciting new capabilities. The team’s dedication has been exceptional, and the community is deeply appreciative of their efforts.

As with projects at the Apache Foundation, Grails doesn’t have a formal project or technical lead. Instead, leadership naturally emerges from those who contribute. James Fredley is one such individual who has been instrumental in driving the team forward on Grails 7. His technical expertise on the complex codebase has been invaluable, but perhaps even more remarkable is his role as a caring and supportive steward of the technology.

James is a sharp technologist who excels in guiding technical discussions, even when opinions clash. His ability to lead these conversations to a productive outcome, regardless of where the team initially stands, demonstrates not only his technical skill but also his exceptional leadership and character. He is a true asset to the team and the community. James’ contributions go far beyond code; his leadership and personal dedication to the Grails project have been key toward making Grails 7 a reality. I do not believe that Grails 7 would be in the great position that it is in right now if it were not for the dedication and commitment that James has invested. It is with great appreciation that we recognize James as a Grails Community Rock Star. Please join us in thanking James Fredley for everything he has done to elevate Grails to new heights. His efforts are deeply valued. James, you truly are a Grails leader and a great person. Please keep up the fantastic work!

Thank you, James!

Join the Grails Slack community, share your feedback, and contribute to making Grails framework even better in the future. Happy coding!

Grails 7.0.0-M1 - Release Announcement

James Fredley — Mon, 23 Dec 2024 00:00:00 GMT

The Grails Foundation is excited for the release of Grails Framework 7.0.0-M1.
We encourage you to try this pre-release and provide your feedback here.

What's Changed

New minimum versions introduced:
1. Gradle 8
2. Groovy 4
3. Java 17
4. Sitemesh 3
5. Spring Boot 3.4 (Spring Framework 6.2)
Default integration of the Micronaut Framework has been removed from Grails. Use Micronaut for Spring to add Micronaut support to your Grails application.

With the release of Grails 7.0.0-M1, we have:

Added support for:
1. Gradle 8.12
2. Groovy 4.0.24
3. Java 17-23, 17 and 21 are LTS
4. Sitemesh 3
5. Spring Boot 3.4.1 & Spring Framework 6.2.1, including transition from javax to jakarta namespace.
Added default support for containerized browser testing using Testcontainers through the Geb Grails Plugin, eliminating web browser version synchronization issues. A container runtime environment is now required for Geb functional and integration tests.
1. This has also been backported for Grails 6.x compatiblility via Geb 4.1.1
Testcontainers features are also available on Grails Forge and Grails Forge CLI for MySQL, PostgreSQL, SQL Server and MongoDB.
Support for Live Reload via Hotswap Agent: current integration details. This was made possible by the removal of the default Micronaut parent application context.
Reintroduced the grails-shell, grails-wrapper and grails-profiles that were removed in Grails 6.
1. Update to the latest wrapper release based on Grails version with ./grailsw update-wrapper
Updated the default styling to use Bootstrap 5.3.3. Both Scaffolding and Fields now support Bootstrap classes.
Reduced deployment sizes (currently pending, due to Graalvm dependencies required for test and bootRun by asset-pipeline).
Enhanced the Grails BOM by adding more versions and extending the Spring Boot BOM for streamlined dependency management. Grails Gradle Plugins apply the BOM by default. If using buildSrc, ensure it is manually applied.
Removed the -plain suffix from the JAR artifact output in Grails Plugin projects.
Disabled all artifact outputs except the JAR artifact for the assemble task in Grails Plugin projects.
Introduced a new tag, g:formActionSubmit, to support submitting forms to different actions. The g:actionSubmit tag is now deprecated and will be removed in a future release.
Introduced a new annotation, @Scaffold, for Controllers and Services to eliminate common boilerplate in the Scaffolding Plugin.
Resolved multiple issues related to Controller namespace support.
Begun the process of discontinuing bean overriding in the core framework by adopting standard Spring Auto-configuration.
Enhanced the g:form tag to include CSRF protection when Spring Security CSRF is enabled.
Decoupled a significant amount of dependencies in Grails, enabling easier maintenance moving forward.
Upgraded external dependencies to the latest available versions.
Removed tight coupling with Sitemesh. Sitemesh 3 is now the default version.
Default Support for evironment specific logging configuration via Spring Logback Extensions in logback-spring.xml
Grails Forge does not generate buildSrc/ or settings.gradle by default, but they are optional features. This simplifies build and Gradle plugin configuration and consolidates version management into one location.

Dependency Upgrades

Staying current with the latest dependencies is essential for the health of any framework. In this release, we've upgraded several dependencies to their latest versions, including but not limited to the following:

Asset Pipeline 5.0.5
Geb 7.0
H2 2.3.232
Hibernate 5.6.15.Final (Jakarta version)
Jackson 2.18.2
Jakarta Servlet 6.0.0
JUnit 5.11.4
Sitemesh 3.2.2
Slf4j 2.0.16
Snakeyaml 2.3
Spring Boot 3.4.1
Spring Framework 6.2.1
Tomcat 10.1.34
see all on Grails-BOM

As part of the Grails 7.0.0-M1 release we have also released milestones of the following:

org.grails.plugins:async:6.0.0-M2
org.grails.plugins:audit-logging:6.0.0-M4
org.grails.plugins:cache:8.0.0-M2
org.grails.plugins:converters:6.0.0-M1
org.grails.plugins:database-migration:6.0.0-M1
org.grails.plugins:events:6.0.0-M2
org.grails.plugins:fields:6.0.0-M1
org.grails.plugins:geb:5.0.0-M2
org.grails.plugins:grails-redis:5.0.0-M1
org.grails.plugins:grails-web-console:7.0.0-M2
org.grails.plugins:gsp:7.0.0-M1
org.grails.plugins:hibernate5:9.0.0-M2
org.grails.plugins:mongodb:9.0.0-M2
org.grails.plugins:quartz:4.0.0-M1
org.grails.plugins:scaffolding:6.0.0-M1
org.grails.plugins:spring-security-core:7.0.0-M1
org.grails.plugins:spring-security-ldap:5.0.0-M2
org.grails.plugins:spring-security-rest:6.0.0-M1
org.grails.plugins:spring-security-rest-gorm:6.0.0-M1
org.grails.plugins:spring-security-rest-grailscache:6.0.0-M1
org.grails.plugins:spring-security-rest-memcached:6.0.0-M1
org.grails.plugins:spring-security-rest-redis:6.0.0-M1
org.grails.plugins:spring-security-rest-testapp-profile:6.0.0-M1
org.grails.plugins:views-gradle:4.0.0-M1
org.grails.plugins:views-json:4.0.0-M1
org.grails.plugins:views-json-templates:9.0.0-M2
org.grails.plugins:views-markup:4.0.0-M1
org.grails.profiles:angular:10.0.1
org.grails.profiles:base:7.0.1
org.grails.profiles:plugin:7.0.1
org.grails.profiles:profile:7.0.1
org.grails.profiles:react:7.0.1
org.grails.profiles:rest-api:7.0.1
org.grails.profiles:rest-api-plugin:7.0.1
org.grails.profiles:vue:7.0.1
org.grails.profiles:web:7.0.1
org.grails.profiles:web-plugin:7.0.1
org.grails:grails-async:6.0.0-M2
org.grails:grails-async-gpars:6.0.0-M2
org.grails:grails-async-rxjava:6.0.0-M2
org.grails:grails-async-rxjava2:6.0.0-M2
org.grails:grails-bootstrap:7.0.0-M1
org.grails:grails-codecs:7.0.0-M1
org.grails:grails-console:7.0.0-M1
org.grails:grails-core:7.0.0-M1
org.grails:grails-databinding:7.0.0-M1
org.grails:grails-datastore-async:9.0.0-M2
org.grails:grails-datastore-core:9.0.0-M2
org.grails:grails-datastore-gorm:9.0.0-M2
org.grails:grails-datastore-gorm-async:9.0.0-M2
org.grails:grails-datastore-gorm-hibernate5:9.0.0-M2
org.grails:grails-datastore-gorm-mongodb:9.0.0-M2
org.grails:grails-datastore-gorm-rx:9.0.0-M2
org.grails:grails-datastore-gorm-support:9.0.0-M2
org.grails:grails-datastore-gorm-tck:9.0.0-M2
org.grails:grails-datastore-gorm-test:9.0.0-M2
org.grails:grails-datastore-gorm-validation:9.0.0-M2
org.grails:grails-datastore-web:9.0.0-M2
org.grails:grails-dependencies:7.0.0-M1
org.grails:grails-docs:7.0.0-M1
org.grails:grails-encoder:7.0.0-M1
org.grails:grails-events-gpars:6.0.0-M2
org.grails:grails-events-rxjava:6.0.0-M2
org.grails:grails-events-rxjava2:6.0.0-M2
org.grails:grails-gorm-testing-support:4.0.0-M2
org.grails:grails-gradle-model:7.0.0-M1
org.grails:grails-gradle-plugin:7.0.0-M3
org.grails:grails-gsp:7.0.0-M1
org.grails:grails-logging:7.0.0-M1
org.grails:grails-plugin-codecs:7.0.0-M1
org.grails:grails-plugin-controllers:7.0.0-M1
org.grails:grails-plugin-databinding:7.0.0-M1
org.grails:grails-plugin-datasource:7.0.0-M1
org.grails:grails-plugin-domain-class:7.0.0-M1
org.grails:grails-plugin-i18n:7.0.0-M1
org.grails:grails-plugin-interceptors:7.0.0-M1
org.grails:grails-plugin-mimetypes:7.0.0-M1
org.grails:grails-plugin-rest:7.0.0-M1
org.grails:grails-plugin-services:7.0.0-M1
org.grails:grails-plugin-url-mappings:7.0.0-M1
org.grails:grails-plugin-validation:7.0.0-M1
org.grails:grails-shell:7.0.0-M1
org.grails:grails-spring:7.0.0-M1
org.grails:grails-test:7.0.0-M1
org.grails:grails-testing-support:4.0.0-M2
org.grails:grails-test-suite-base:7.0.0-M1
org.grails:grails-test-suite-persistence:7.0.0-M1
org.grails:grails-test-suite-uber:7.0.0-M1
org.grails:grails-test-suite-web:7.0.0-M1
org.grails:grails-web:7.0.0-M1
org.grails:grails-web-boot:7.0.0-M1
org.grails:grails-web-common:7.0.0-M1
org.grails:grails-web-databinding:7.0.0-M1
org.grails:grails-web-gsp:7.0.0-M1
org.grails:grails-web-mvc:7.0.0-M1
org.grails:grails-web-taglib:7.0.0-M1
org.grails:grails-web-testing-support:4.0.0-M2
org.grails:grails-web-url-mappings:7.0.0-M1
org.grails:grails7-wrapper:6.0.0
org.grails:views-json-testing-support:4.0.0-M1

Installing Grails 7.0.0-M1

Try out Grails 7.0.0-M1 today by visiting the online app creator * Grails Forge. Alternatively, you can quickly install Grails 7.0.0-M1 using the SDKMan.

If you don't have SDKMan installed, follow the instructions at SDKMan Installation Guide to set it up.
Once SDKMan is installed, open your terminal and run the following command to install Grails 7.0.0-M1:
```
sdk install grails 7.0.0-M1
```
You're all set! To verify the installation, run:
```
grails --version
```

Upgrading Your Existing Applications to Grails 7.0.0-M1

If you already have a Grails application and want to upgrade to the latest version, follow these steps:

Open the project in your favorite IDE (preferably JetBrains' IntelliJ IDEA).
Update your application's gradle.properties file to specify Grails 7.0.0-M1 as the desired version.
```
grailsVersion=7.0.0-M1
grailsGradlePluginVersion=7.0.0-M3
```
Make any necessary adjustments to your application code, configuration, and dependencies to ensure compatibility with the new version. See https://grails.apache.org/docs/7.0.0-M1/guide/upgrading.html#upgrading60x.

By following these steps, you can smoothly transition your existing Grails application to the exciting Grails 7.0.0-M1.

Exploring Alternative Approaches

If manual dependency updates seem daunting, or you want a more streamlined approach, consider the following alternatives:

1. Use Grails Forge Website

Visit Grails Forge and generate a new Grails application with Grails 7.0.0-M1. Compare the versions in the newly generated application with your existing one to identify any discrepancies. This can serve as a reference point for your update.

2. Automated Dependency Update Bots

With these steps and alternative approaches, you should be well on your way to enjoying the exciting features and improvements in Grails 7.0.0-M1. Happy coding!

Why should you try out Grails 7.0.0-M1?

Help us test this major upgrade of the Grails Framework and provide feedback.
Be ready for when Grails 7 is released.

Grails 7 Release Schedule

We will continue to work on updating and fixing issues over the next few weeks.
Grails 7 M2 will be released thereafter.
Based on feedback, a Grails GA or RC release is targeted for March 2025.

Thank you!

Big thanks to our wonderful community of users for your continued support of the Grails Framework over the past 19 years! With a hopeful outlook towards the future and a deep sense of gratitude, we eagerly anticipate the path that lies ahead, embracing the invaluable chance to develop and pioneer new advancements within this framework.

Contributors

We would like to extend our heartfelt thanks to all the contributors who made Grails 7.0.0-M1 possible. Special thanks to:

Their dedication and hard work have significantly contributed to the release of Grails 7.0.0-M1.

Join the Grails Slack Community, share your feedback, and contribute to making Grails Framework even better in the future. Happy coding!

Introducing Grails Framework 6.2.2 Release

James Fredley — Wed, 20 Nov 2024 00:00:00 GMT

The Grails Foundation is excited to announce the release of Grails framework 6.2.2. This latest version delivers bug fixes and reintroduces key features based on community feedback.

What's Changed

In this release, we have made several changes to improve the framework's performance and maintainability. Some of the notable changes include:

Simplify Generated Build:
- Consolidates Gradle Plugin configuration to buildscript{}, plugins{} and apply plugin: in build.gradle
- Changes Gradle buildSrc/build.gradle and Settings File to non-default, optional features
- When the Gradle Settings File feature is selected, it only contains one line defining the root project
- When the Gradle buildSrc feature is selected buildscript{} is not generated, they are equivalent
- These changes allow Gradle plugins to be defined in one location and for consolidation of dependency version resolution.
Grails Wrapper:
- Make grails-wrapper a default feature
- Ensure grails-wrapper files exist in native grails-forge-cli builds
- Put profile information in all locations required by grails-shell and grails-wrapper

Bug Fixes and Improvements

Grails 6.2.2 also addresses several bug fixes and improvements, including:

Set asset-pipeline skipNonDigest to true, which reduces jar/war files size
Include development, test and production dataSource configurations in generated application.yml
Default generated applications to Java 11, 17 is optional
gorm-hibernate5: Create foreign key constraint when tablePerHierarchy=false
Remove -plain from Grails plugin jar filenames
fields: Fix for invalid class not rendering on widget
scaffolding: remove dependency on org.grails:grails-dependencies

These updates will enhance the stability and reliability of the framework.

Dependency Upgrades

org.grails:grails-gradle-plugin to version 6.2.3
org.codehaus.groovy:groovy to version 3.0.23
org.grails.plugins:hibernate5 to version 8.1.1
com.bertramlabs.asset-pipeline to version 4.5.1
com.bertramlabs.asset-pipeline:asset-pipeline-grails to version 4.5.1
org.grails.plugins:fields to version 5.1.1
org.grails.plugins:scaffolding to version 5.1.3
org.grails.plugins:gsp to version 6.2.4
org.apache.tomcat:tomcat-jdbc to version 9.0.97
org.apache.tomcat.embed:tomcat-embed-core to version 9.0.97
org.apache.ant:ant to version 1.10.15
org.aspectj:aspectjrt to version 1.9.22.1
org.mongodb:mongo-driver to version 4.11.5
And many more transitive dependencies.

These upgrades ensure that Grails 6.2.2 remains compatible with the latest libraries and tools, providing developers with a robust and reliable environment. We recommend checking out the GitHub release page for more information.

Installing Grails 6.2.2

You can get started with Grails 6.2.2 today by visiting our official website. Alternatively, you can quickly install Grails 6.2.2 using the SDKMan.

If you don't have SDKMan installed, follow the instructions at SDKMan Installation Guide to set it up.
Once SDKMan is installed, open your terminal and run the following command to install Grails 6.2.2:
```
sdk install grails 6.2.2
```
You're all set! To verify the installation, run:
```
grails --version
```

Upgrading Your Existing Applications to Grails 6.2.2

If you already have a Grails application and want to upgrade to the latest version, follow these steps:

Open the project in your favorite IDE (preferably JetBrains' IntelliJ IDEA).
Update your application's gradle.propreties file to specify Grails 6.2.2 as the desired version.
```
grailsVersion=6.2.2
grailsGradlePluginVersion=6.2.3
```
Make any necessary adjustments to your application code, configuration, and dependencies to ensure compatibility with the new version.

By following these steps, you can smoothly transition your existing Grails application to the exciting Grails 6.2.2.

Exploring Alternative Approaches

If manual dependency updates seem daunting, or you want a more streamlined approach, consider the following alternatives:

1. Use Grails Forge Website

Visit https://start.grails.org and generate a new Grails application with Grails 6.2.2. Compare the versions in the newly generated application with your existing one to identify any discrepancies. This can serve as a reference point for your update.

2. Automated Dependency Update Bots

With these steps and alternative approaches, you should be well on your way to enjoying the exciting features and improvements in Grails 6.2.2. Happy coding!

Contributors

We would like to extend our heartfelt thanks to all the contributors who made Grails 6.2.2 possible. Special thanks to:

Their dedication and hard work have significantly contributed to the success of Grails 6.2.2.

With all these exciting changes and improvements, Grails 6.2.2 is set to offer an even better experience for developers working on web applications. Whether you're an experienced Grails developer or just getting started, this release has something for everyone.

Join the Grails Slack community, share your feedback, and contribute to making Grails framework even better in the future. Happy coding!

Introducing Grails Framework 6.2.1 Release

James Fredley — Thu, 03 Oct 2024 00:00:00 GMT

The Grails Foundation is excited to announce the release of Grails framework 6.2.1. This latest version delivers critical bug fixes and reintroduces key features based on community feedback.

What's Changed

The 6.2.1 release, while being a patch release, brings back the Grails Shell, Profiles and Wrapper (as an optional feature) and addresses some bugs.

Grails Shell, Profiles and Wrapper:
- Reintroduces the Grails Shell and Profiles in response to community feedback, addressing a key feature loss identified by users including:
  - enables the IntelliJ Grails Plugin to load in IntelliJ
  - execution of Grails scripts that have not been migrated to Gradle such as grails list-plugins and grails dbm-update
  - execution of custom company/internal Grails scripts
  - continued use of custom company/internal profiles
- Grails Wrapper is now an optional feature from Grails Forge via the Grails distribution or https://start.grails.org/
  - you can now run ./grailsw update-wrapper to get the latest grails wrapper version based on the Grails version

Bug Fixes and Improvements

Grails 6.2.1 also addresses several bug fixes and improvements, including:

Fixes a lack of a “controller” attribute in GSP tags with a “resource” attribute
Fixes a bug in LinkGenerator when domain classes have a static id mapping to another property, that is not “id”
Fixes a problem finding the main class when running CLI commands
Fixes an edge cases that causes a cast class exception when the same variable name is used as arguments to multiple actions

These updates will enhance the stability and reliability of the framework.

Dependency Upgrades

com.github.javaparser:javaparser-core to version 3.25.10
ch.qos.logback:logback-classic to version 1.2.13
org.springframework:spring-core to version 5.3.39
org.grails:grails-testing-support to version 3.2.2
org.apache.tomcat:tomcat-jdbc to version 9.0.95
org.grails.plugins:fields to version 5.1.0
org.grails.plugins:scaffolding to version 5.1.2
org.grails:grails-shell to version 6.2.1
org.grails:grails6-wrapper to version 4.0.1
org.grails.plugins:gsp to version 6.2.2
org.grails.profiles:base to version 6.0.1
org.grails.profiles:web to version 6.0.1
org.grails.profiles:profile to version 6.0.1
org.grails.profiles:plugin to version 6.0.1
org.grails.profiles:web-plugin to version 6.0.1
org.grails.profiles:rest-api to version 6.0.1
org.grails.profiles:rest-api-plugin to version 6.0.1
org.grails.profiles:react to version 6.0.1
org.grails.profiles:vue to version 6.0.1
org.grails.profiles:angular to version 9.0.1
And many more transitive dependencies.

These upgrades ensure that Grails 6.2.1 remains compatible with the latest libraries and tools, providing developers with a robust and reliable environment. We recommend checking out the GitHub release page for more information.

Installing Grails 6.2.1

You can get started with Grails 6.2.1 today by visiting our official website. Alternatively, you can quickly install Grails 6.2.1 using the SDKMan.

If you don't have SDKMan installed, follow the instructions at SDKMan Installation Guide to set it up.
Once SDKMan is installed, open your terminal and run the following command to install Grails 6.2.1:
```
sdk install grails 6.2.1
```
You're all set! To verify the installation, run:
```
grails --version
```

Upgrading Your Existing Applications to Grails 6.2.1

If you already have a Grails application and want to upgrade to the latest version, follow these steps:

Open the project in your favorite IDE (preferably JetBrains' IntelliJ IDEA).
Update your application's gradle.propreties file to specify Grails 6.2.1 as the desired version.
```
grailsVersion=6.2.1
grailsGradlePluginVersion=6.2.1
```
Make any necessary adjustments to your application code, configuration, and dependencies to ensure compatibility with the new version.

By following these steps, you can smoothly transition your existing Grails application to the exciting Grails 6.2.1.

Exploring Alternative Approaches

If manual dependency updates seem daunting, or you want a more streamlined approach, consider the following alternatives:

1. Use Grails Forge Website

Visit https://start.grails.org and generate a new Grails application with Grails 6.2.1. Compare the versions in the newly generated application with your existing one to identify any discrepancies. This can serve as a reference point for your update.

2. Automated Dependency Update Bots

With these steps and alternative approaches, you should be well on your way to enjoying the exciting features and improvements in Grails 6.2.1. Happy coding!

Contributors

We would like to extend our heartfelt thanks to all the contributors who made Grails 6.2.1 possible. Special thanks to:

Their dedication and hard work have significantly contributed to the success of Grails 6.2.1.

With all these exciting changes and improvements, Grails 6.2.1 is set to offer an even better experience for developers working on web applications. Whether you're an experienced Grails developer or just getting started, this release has something for everyone.

Join the Grails Slack community, share your feedback, and contribute to making Grails framework even better in the future. Happy coding!

Grails Community Contributions

James Fredley — Tue, 01 Oct 2024 00:00:00 GMT

Grails Community Contributions

As a follow-up to our blog post a few months ago, we have worked with the community to assemble a Grails Community Steering Committee and enabled GitHub Discussions in the grails GitHub org to solicit feedback on a number of topics. The goal of this was to help design a path forward for the Grails framework. One of the first priorities was to define the scope for a meaningful and valuable Grails 7. This effort required significant contributions from a combination of passionate community members and organizations who care about being involved in the future of the technology. We are pleased with the progress the Steering Committee has made so far as efforts continue to be made towards the Grails framework 7 MVP.

When the committee was initially put together, we did not reach out to individuals, but instead let members of the community volunteer their time and efforts as they felt they could help. We want to continue to create awareness and encourage community participation. Please join us here in our Grails Community Slack to get involved. Additionally, there is a 60-minute online meeting each Thursday at 10:00am US Central during which the team will be discussing priorities for the technology and helping to manage governance of the Framework.

We want to thank you in advance for your continued support of the Grails framework and our amazing community.

Grails 7 MVP

Jeff Brown — Tue, 25 Jun 2024 00:00:00 GMT

MVP (Minimum Viable Product) for Grails 7.

The Grails Community Steering Committee has begun discussions on the MVP (Minimum Viable Product) for Grails 7. To assist in these discussions, the Grails Foundation has enabled GitHub Discussions on the grails-core project. We now need the community’s feedback!

Please vote on the various posted polls and respond to the existing discussions to help with decisions on priorities for the Grails 7 MVP.

Thank you for all of your input!

Grails Future Planning

Jeff Brown — Fri, 07 Jun 2024 00:00:00 GMT

Grails Community Steering Committee is working on plans for the future of the Grails framework.

The Grails Foundation would like to follow up on the Open Letter To Our Community that was recently published by Object Computing, Inc. (OCI).
We have assembled a Grails Community Steering Committee with the goal of helping define the path forward for the Grails framework. One of the first priorities of the group is to define the scope for a meaningful and valuable Grails 7, which can be created and supported responsibly. Achieving that will require contributions from a combination of passionate community members and organizations who care about being involved in the future of the technology.

Our experience has shown that increased transparency regarding challenges and opportunities is crucial for the Framework's continued development. We're committed to improving communication in this area.

The Grails Steering Committee’s current focus is on three key goals:

Defining an MVP (Minimum Viable Product) for Grails 7.
Outlining Community Contribution Opportunities: We'll clearly define how individuals and organizations can contribute to the MVP's development.
Highlighting Contribution Methods: We recognize that contributions come in various forms. Some organizations may prefer dedicating engineering resources, while others might choose to provide financial support for a core development team.

Previously, these contribution avenues have existed but lacked clear communication. We're committed to making them more visible and accessible.

The work we are doing right now will enable our community to have a greater impact on the future of the Grails framework. The feedback we get in the coming weeks will be enlightening. We must understand what is important from the community’s perspective, and for us to envision the possible paths to accomplish desired outcomes. OCI is committed to stewarding the framework forward including helping the technology and the community find a public place for the community to rally around the technology.

Creating and maintaining these free and open solutions is a significant commitment and it will take a positively energized community to help us carry things forward. Every single message we have received and every single conversation we have been involved in in recent weeks has been helpful, appreciated, and respectful. This community is remarkable and your input is sincerely appreciated.

We will continue to communicate more information here in the coming weeks. Always feel welcome to reach out to us at dev@grails.apache.org if you have any questions, concerns, or would like to engage in ways that you are currently not. Together we are all defining the way forward and your help is appreciated.

CVE-2023-46131: Data Binding Denial of Service Vulnerability

Matthew Moss — Wed, 20 Dec 2023 00:00:00 GMT

A vulnerability in grails-core data binding can leave your application open to a denial-of-service attack.

Overview

The Grails® framework engineering team has confirmed a security vulnerability in the grails-databinding module, discovered by Wenbo Shen, Rui Chang, crane from Zhejiang University, and two other researchers from Antgroup FG Security Lab. This vulnerability is assigned the identifier CVE-2023-46131.

An attacker can send a specially crafted request to a Grails framework application that will trigger internal server errors when the application attempts data binding. After the attack, these internal server errors will continue to be generated, even after the attacker has moved on and the application has received valid requests. The attack request may even crash the Java Virtual Machine (JVM). The server must be restarted to restore proper working operation.

Impacted Applications

Most Grails framework applications are susceptible, from Grails version 2.x and later.

Protecting Your Applications

The Grails Team recommends that all Grails framework applications upgrade to a patched version of the framework. Patches are available for Grails in these versions:

(2024 Jan 29 Update: An earlier revision of this blog post recommended release versions that patched the vulnerability but unfortunately introduced an unrelated defect. This defect has been fixed, and the recommended versions above reflect the patched, fixed releases.)

The best way to protect your application is to upgrade to a patched release.

No workaround is possible for this vulnerability except to avoid data binding altogether.

Support

The Grails Foundation and the Grails development team take application security very seriously. We continue to research and monitor this vulnerability and will post updates with new information as it is discovered.

If you have questions about this vulnerability or need assistance with upgrades or workarounds, please join the discussion on GitHub or contact us at security@apache.org.

Introducing Grails Framework 6.1.0 Release

Puneet Behl — Tue, 14 Nov 2023 00:00:00 GMT

The Grails Foundation is excited to announce the release of Grails Framework 6.1.0! This release comes with a host of changes, bug-fixes, and improvements that will further enhance your experience with the Grails framework . Grails continues to be a powerful and efficient framework for building web applications in Groovy, and this latest version takes it to the next level. Let's dive into what's new in Grails 6.1.0.

What's Changed

In this release, we have made several changes to improve the framework's performance and maintainability. Some of the notable changes include:

Update to SnakeYaml 2.2: This update fixes the CVE-2022-1471 reported in December of last year. This unsafe deserialization problem could easily lead to arbitrary code execution under the right circumstances. For more details on this vulnerability, you can read about it on Snyk's blog.
Decoupling the Sitemesh Plugin: We have introduced significant changes to decouple the Sitemesh plugin for more flexibility. Here are the details:
1. Created a new org.grails.plugins:sitemesh2 and moved Sitemesh specific tag libraries that require the Sitemesh2 dependency into a separate Sitemesh2 specific plugin. This plugin can now be optionally used, providing more flexibility in choosing Sitemesh versions.
2. Introducing the Sitemesh3 Grails Plugin, a new plugin that can be independently used with Grails 6. This plugin offers compatibility with the latest Sitemesh version, allowing developers to leverage the benefits of Sitemesh3 in their Grails applications.
3. To migrate from Sitemesh 2 to Sitemesh 3, not only completely decouples Sitemesh from GSP, but it also introduces a powerful new feature that GSP has been lacking: Decorator Chaining. With SiteMesh 3, you can apply multiple decorators to a view. For instance, something like this:
  This enhancement provides more flexibility in structuring views and layouts, making it easier to create complex and dynamic page layouts.
4. Going Further (JDK 17) - Jakarta compatible SiteMesh 3.2 is already available. Sitemesh 3 supports JDK 17, making it an easier transition to future Grails releases, such as Grails 7.0.
5. To learn more about updates around Grails and Sitemesh, please review the discussion. This discussion provides insights into the decisions and considerations made during the decoupling process.
These changes aim to provide developers with more choices and the ability to use the Sitemesh version that best suits their application requirements.
Updated Micronaut Groovy to version 3.4.0 for better compatibility.
Escaped Javadoc special characters for improved documentation.
Update Spring Core to 5.3.30, and Spring Boot 2.7.16.
Updated various dependencies and plugins to their latest versions.

These changes will not only make Grails more efficient but also ensure that it remains current and compatible with the latest technologies.

Bug Fixes and Improvements

Grails 6.1.0 also addresses several bug fixes and improvements, including:

An update to GSP version 6.1.0.
An update to the grails-testing-support monorepo to version 3.1.0.

These updates will enhance the stability and reliability of the framework.

Dependency Upgrades

commons-io:commons-io to version 2.15.0.
org.jsoup:jsoup to version 1.16.2.
org.grails:grails-datastore-gorm-hibernate5 to 8.0.1.
Micronaut to version 3.10.2.
Gradle to version 7.6.3.
Apache Tomcat to 9.0.81.
JUnit Jupiter to 5.10.0, and JUnit Platform to 1.10.0.
And many more.

These upgrades ensure that Grails 6.1.0 remains compatible with the latest libraries and tools, providing developers with a robust and reliable environment. We recommend checking out the GitHub release page for more information.

Installing Grails 6.1.0

You can get started with Grails 6.1.0 today by visiting our official website. Alternatively, you can quickly install Grails 6.1.0 using the SDKMan.

If you don't have SDKMan installed, follow the instructions at SDKMan Installation Guide to set it up.
Once SDKMan is installed, open your terminal and run the following command to install Grails 6.1.0:
```
sdk install grails 6.1.0
```
You're all set! To verify the installation, run:
```
grails --version
```

Upgrading Your Existing Applications to Grails 6.1.0

If you already have a Grails application and want to upgrade to the latest version, follow these steps:

Open the project in your favorite IDE (preferably JetBrains' IntelliJ IDEA).
Update your application's gradle.propreties file to specify Grails 6.1.0 as the desired version.
```
grailsVersion=6.1.0
grailsGradlePluginVersion=6.1.0
```
Make any necessary adjustments to your application code, configuration, and dependencies to ensure compatibility with the new version.

By following these steps, you can smoothly transition your existing Grails application to the exciting Grails 6.1.0.

Exploring Alternative Approaches

If manual dependency updates seem daunting or you want a more streamlined approach, consider the following alternatives:

1. Use Grails Forge Website

Visit https://start.grails.org and generate a new Grails application with Grails 6.1.0. Compare the versions in the newly generated application with your existing one to identify any discrepancies. This can serve as a reference point for your update.

2. Automated Dependency Update Bots

With these steps and alternative approaches, you should be well on your way to enjoying the exciting features and improvements in Grails 6.1.0. Happy coding!

Contributors

We would like to extend our heartfelt thanks to all the contributors who made Grails 6.1.0 possible. Special thanks to:

Their dedication and hard work have significantly contributed to the success of Grails 6.1.0.

With all these exciting changes and improvements, Grails 6.1.0 is set to offer an even better experience for developers working on web applications. Whether you're an experienced Grails developer or just getting started, this release has something for everyone.

Join the Grails Slack community, share your feedback, and contribute to making Grails framework even better in the future. Happy coding!

Introducing the New Grails Plugin Portal - A Static Marvel!

Puneet Behl — Mon, 11 Sep 2023 00:00:00 GMT

Hey there, Grails enthusiasts! Are you ready for some exciting news? We're thrilled to introduce the revamped Grails Plugin Portal, and let us tell you, it's a game-changer! This dynamic portal is now completely static and hosted on GitHub, offering you a seamless and efficient experience in exploring Grails plugins.

A Glimpse of the Future: Grails Plugin Portal Redesigned

Our dedicated team has been hard at work, and we're excited to unveil the Grails Plugin Portal 2.0, now hosted at https://github.com/apache/grails-static-website. What's our aim? To make your Grails plugin journey smoother and more accessible than ever before!

Key Features of the New Grails Plugin Portal

Quick and Easy Search Functionality

We get it, time is precious when you're deep into Grails projects. That's why our new portal boasts a lightning-fast search feature. Type in your keywords, hit enter, and voilà! Your desired plugins are right there at your fingertips.

Paginated List of All Plugins

With the Grails ecosystem booming, there's no shortage of plugins to explore. To help you navigate this sea of possibilities, we've introduced a paginated list of all available plugins. Explore them at your pace, knowing that detailed plugin info is just a click away.

Top-Rated Plugins

Wondering which plugins are the cream of the crop? Wonder no more! Our top-rated plugins section showcases gems that have been tried, tested, and adored by fellow Grails developers. It's your shortcut to finding the best tools for your projects.

Latest Release Plugins

Stay ahead in the world of Grails development with our "Latest Release" section. We keep it up to date to showcase the newest additions to the Grails plugin ecosystem. Be the first to try out fresh features and improvements as they roll in.

Limitations of the Previous Plugin Portal

Before we dive further into the awesomeness of the new portal, let's address the shortcomings of the previous version. It had some issues that weren't exactly developer-friendly:

Frequent Downtime: The old portal was notorious for going offline quite often, causing disruptions and frustration for developers.
High Resource Utilization: It was a resource-hungry beast, slowing down performance due to its dynamic architecture.
Slow Performance: Slow loading times and delays were common complaints. The dynamic setup struggled with the increasing plugin data, resulting in sluggishness.

All Plugins in One Place

Did you know that all the plugins on the Grails Plugin Portal are sourced from https://github.com/apache/grails-plugins-metadata/tree/grails-plugins.json? We've streamlined the process to ensure you have access to the most up-to-date plugins directly from the source.

How to Include or Update Your Grails Plugin

Excited to get your Grails plugin into the spotlight on our portal? Here's how you can include or update your Grails plugin:

Fork the Repository: Start by forking the Grails Plugin Metadata Repository.
Edit the JSON File: Navigate to the grails-plugins.json file in your forked repository. This file contains the plugin metadata.
Add Your Plugin: To include your plugin, simply add its metadata to the JSON file. Make sure to follow the established format.
Submit a Pull Request: Once you've added or updated your plugin details, submit a pull request to the original Grails Plugin Metadata Repository. Our team will review it and, upon approval, your plugin will be part of the portal!

Get Involved and Contribute

But here's the exciting part: the Grails Plugin Portal is not just a resource; it's a community effort! We're eager to hear your thoughts and welcome your contributions. Have a Grails plugin you'd like to share, or ideas for portal enhancements? Join us on GitHub, and together, we'll make Grails development a breeze!

Embrace the Future of Grails Plugin Discovery

The new Grails Plugin Portal is your gateway to a brighter future in Grails development. With its static structure, lightning-fast search, and curated lists of top-rated and latest release plugins, it's your one-stop-shop for all things Grails. Come on in, explore, discover, and become an active part of the Grails community. Let's build amazing Grails applications together with this reimagined portal!

Ready to get started? Visit the Grails Plugin Portal today!

Introducing Grails Spring Security Core Plugin 6.0.0 - Elevated Security, Grails 6 Compatibility, Enhanced Commands, and Effortless Documentation

Puneet Behl — Fri, 25 Aug 2023 00:00:00 GMT

Exciting News from the Grails Foundation: Unveiling Grails Spring Security Core Plugin 6.0.0

Greetings, fellow developers! Prepare to be amazed by the latest release – Grails Spring Security Core Plugin 6.0.0! This isn't just an upgrade in security; it's a journey towards greater heights for your applications. Packed with updates and improvements, this release doesn't just enhance security; it also streamlines your development experience. Let's explore the exciting changes this release brings.

Seamless Grails 6 Compatibility with Upgraded Commands

We are intentional about making the transition to Grails 6 seamless. Grails Spring Security Core Plugin 6.0.0 now boasts upgraded commands fully compatible with Grails 6. This is crucial because the old scripts you might have been using would have caused compatibility issues with Grails 6. But worry not! We've revamped these commands, ensuring a smooth transition and allowing you to continue using them seamlessly.

Do you remember running a script like s2-quickstart using the command:

grails s2-quickstart com.yourapp User Role

This command was used to create user and role classes (and optionally a requestmap class) in your specified package.

Fast forward to Grails 6, things have evolved. Now, you can trigger these commands using Gradle tasks, like so:

./gradlew runCommand "-Pargs=s2-quickstart com.yourapp User Role"

The runCommand Gradle task allows you to execute various Grails ApplicationCommands, just like the good old s2-quickstart. The difference? It's sleeker, perfectly aligned with Grails 6, and propels your app into modern development.

Spring Security Leveled Up to 5.8.6

Security is paramount, and that's why we've given the underlying Spring Security framework a power boost in Grails Spring Security Core Plugin. It's now fueled by version 5.8.6 of Spring Security. This ensures that your application benefits from the latest security enhancements and bug fixes from the Spring Security team. By staying up to date with Spring Security versions, your app is fortified against emerging threats and vulnerabilities.

Navigating Docs Made Effortless

We've heard your feedback – navigating documentation shouldn't be a chore. That's why we've spruced up the Internal Docs task. This magic generates documentation that empowers you to grasp the plugin's features and their effective usage. But there's more – we've added a slick select drop-down feature. This nifty addition enables you to switch effortlessly between documentation for different releases. Whether diving into the latest version or revisiting an older one, finding the info you need is now seamless.

All Aboard the Grails 6 Train

Web development is a swiftly moving train, and the Grails Spring Security Core Plugin is on board. We've given it a makeover for seamless integration with Grails 6. This empowers you to tap into the coolest Grails framework features while enjoying the robust security provided by the plugin.

Getting Cozy with Dependency Updates

Dependencies are the foundation of your app, and keeping them up-to-date is crucial. In Grails Spring Security Core Plugin 6.0.0, we've rolled out updates to key dependencies:

Spring Security 5.8.6: Latest Spring Security version for cutting-edge security features.
Hibernate 5: Upgraded to version 8, embracing enhancements in Hibernate technology.
Spring Security Core 5.3.0: Now at version 5.3.0, aligning with latest developments in the Spring Security ecosystem.
Grails Gradle Plugin 6: Elevating your build and development experience with Grails Gradle Plugin v6.
Webdriver Binaries 3.2: For web testing enthusiasts, Webdriver Binaries plugin updated to v3.2, enhancing testing capabilities.
Spring Dependency Management 1.1.3: Details matter – Spring Dependency Management plugin upgraded to v1.1.3, simplifying project dependency management.

Embrace the Future

Grails Spring Security Core Plugin 6.0.0 release goes beyond security enhancement; it's a stride towards improved compatibility and integration. The transition from Grails scripts to Grails ApplicationCommand underscores the plugin's commitment to delivering a unified and consistent experience in the realm of Grails 6. As you embark on secure, robust web app development, the upgraded plugin is your ally, aligning projects with the evolving landscape of modern web development. Upgrade today for a new era of security and compatibility in your Grails applications!

How to Upgrade

To use the

latest Grails Spring Security Core plugin, simply edit your build.gradle file and change the dependency from version 5.3.0 to version 6.0.0:

From:

implementation 'org.grails.plugins:spring-security-core:5.3.0'

To:

implementation 'org.grails.plugins:spring-security-core:6.0.0'

Updating your project's dependencies is all it takes. Your application is now upgraded to Grails Spring Security Core Plugin 6.0.0, ready to take advantage of enhanced security, smoother documentation navigation, and Grails 6 compatibility.

Glimpse into the Future

But wait, there's more! As you enjoy these enhancements in Grails Spring Security Core Plugin 6.0.0, we want to give you a sneak peek into the exciting future. Our team is actively working on upgrading the Grails Spring Security REST plugin, bringing you even more comprehensive security features and seamless integration.

And that's not all. Our vision extends further down the road. We're planning to support the next major release, Spring Security 6, with a focus on addressing bug fixes and introducing further improvements. This dedication to staying ahead of the curve ensures that your applications will continue to be fortified with the latest security advancements and enhancements.

So, as you relish the benefits of Grails Spring Security Core Plugin 6.0.0, rest assured that the journey ahead is just as thrilling. We're committed to providing you with the tools you need to build exceptional, secure, and future-proof web applications. Stay tuned for more updates as we continue this innovative journey together!

Introducing the New Grails Forge - A Lightning-Fast, Micronaut-Inspired CLI for Grails Application Generation

Puneet Behl — Thu, 03 Aug 2023 00:00:00 GMT

Dear Grails Developers,

The Grails Foundation™ is thrilled to unveil the next level of Grails application generation - the New Grails Forge! Building upon the foundation of the previous Grails Forge, we have introduced a brand new implementation of the Grails Forge website, and the Grails Command Line Interface (CLI).

Multiple Application Types for Your Needs

The New Grails Forge also introduces Grails Profiles through application-types, supporting various application types to meet your specific needs. Currently, we offer support for Web, REST API, Web Plugin, and Plugin. Stay tuned as we plan to add support for additional application types, including REST API Plugin, React, and Angular.

The New Grails Forge CLI: Speed, Flexibility, and Efficiency

Before we delve into the Grails Forge UI, let's first highlight the power of the New Grails Forge CLI. Inspired by the efficiency and flexibility of the Micronaut framework's CLI, the New Grails Forge CLI offers a lightning-fast and easy-to-maintain approach to creating and managing Grails projects.

With the New Grails Forge CLI, you can create Grails applications offline or in areas with limited connectivity, making it a perfect choice for developers on the go. Powered by the Picocli library, the CLI delivers exceptional performance and robustness, ensuring a smooth and seamless command-line experience.

Getting Started with the Grails Forge UI

Getting started with the Grails Forge UI is as simple as 1, 2, 3:

Visit the Website: Head over to the official Grails Forge UI website at https://start.grails.org
Explore and Customize: Take a tour of the website and explore its features. Customize your project settings to match your development requirements.
Generate Your Project: Once you're satisfied with your choices, hit the "Generate Project" button. Your Grails project will be created instantly, and you can download the project files to get started immediately.

Global CLI Compatibility: The Best of Both Worlds

While many commands transition smoothly to Gradle tasks, we understand that some actions require the familiarity of the globally-installed Grails CLI. Fear not, as the New Grails Forge thoughtfully addresses this concern. If you have the Grails CLI installed on your system, you can still use it within your project folder for commands involving file manipulations. This harmonious integration ensures a seamless transition for existing projects while taking advantage of the new features of the New Grails Forge.

Extending Functionality: A World of Possibilities

The New Grails Forge empowers you to extend the functionality of your projects effortlessly. Although some plugin-specific commands may require slight adjustments during the migration, we've got you covered with our comprehensive Grails Documentation, providing valuable insights into creating custom commands. This newfound capability allows you to tailor commands to your unique needs, automate tasks, integrate with third-party tools, and streamline repetitive processes.

Lightning-Fast and Offline Ready

With the new CLI, you can create Grails applications even offline or in areas with limited connectivity, thanks to its lightning-fast performance. Say goodbye to frustrating delays and embrace a seamless and efficient application generation process.

Powered by Picocli and Rocker Template Engine

To achieve such speed and efficiency, we harnessed the power of the Picocli library to build a robust and flexible command-line application. This integration ensures that you have a user-friendly and highly maintainable CLI at your fingertips.

Moreover, we adopted the Rocker template engine, which produces statically typed plain Java objects, guaranteeing precision and performance in every command you execute.

Saying Farewell to the Grails CLI Wrapper

With Grails 6, we're embracing a new era where the Grails CLI wrapper will no longer be included in new projects. Instead, we encourage you to leverage the Gradle build system for greater flexibility and a more cohesive development environment. Common commands, such as "./grailsw run-app," can now be executed directly using the straightforward "./gradlew bootRun."

Enhanced Plugin Compatibility with Grails ApplicationCommand

While many commands transition seamlessly to Gradle tasks, we acknowledge that certain commands, supported via plugins, may require special attention during migration. To address this, we introduced Grails ApplicationCommand tasks, enabling compatibility with plugin-specific commands. Refer to our comprehensive Grails Documentation for valuable insights on creating custom commands and making the most of this new capability.

Turbocharge Your Grails Development: Swift Installation of the New Grails Forge

Installing the New Grails Forge is a breeze! Follow these step-by-step instructions based on your preferred method:

Option 1: Installing with SDKMan

The easiest way to install the New Grails CLI is with SDKMan. Simply run the following command in your terminal:

sdk install grails 6.0.0

Option 2: Download & Install Binary

Download the latest binary from the following link, based on your Operating System: New Grails CLI Binary
Extract the downloaded zip file to an appropriate directory on your system.
Create an environment variable named "GRAILS_HOME" and set its value to the installation directory, for example:
- On Windows: set GRAILS_HOME=c:/grails
- On macOS/Linux: export GRAILS_HOME=/usr/local/grails
Update the PATH environment variable to include the Grails binary directory. For example:
- On Windows: set PATH=%PATH%;%GRAILS_HOME%\bin
- On macOS/Linux: export PATH=$PATH:$GRAILS_HOME/bin

Option 3: Use SDKMan to Build & Install From Source

Clone the repository with the following command:

git clone https://github.com/apache/grails-forge.git

Build the distribution using the following command:

cd grails-forge
./gradlew :grails-cli:assembleDist

Copy and extract the archive from grails-forge/grails-cli/build/distributions/grails-cli.*.zip to your user home directory.
Use SDKMan to install the development version using the following commands:

sdk install grails dev ~/grails-cli/
sdk use grails dev

Explore the Source Code

Curious about the inner workings of the New Grails Forge? Delve into the source code on GitHub: Grails Forge Core Source Code

Preview Feature: Explore Your Grails Application Source Files

We are excited to introduce the Preview Feature on https://start.grails.org! This powerful addition allows you to take a sneak peek into your Grails application source files before actually generating the project. With the Preview Feature, you can explore the selected options and features to see exactly what will be generated, giving you full control and confidence in your project setup.

How does it work? It's simple:

Customize Your Options: Start by selecting the application type and setting your project preferences, just like you would with the regular project generation process.
Click "Preview": Instead of hitting the "Generate Project" button right away, click on "Preview" to see the magic happen.
Visualize Your Project: The Preview Feature will instantly generate a visualization of your Grails application source files, showcasing the directory structure and all the code files based on your chosen options.
Navigate and Inspect: Dive into the source files, navigate through the directories, and inspect the actual code snippets that will be included in your project.
Refine and Adjust: If you spot anything you'd like to modify, simply go back, adjust your options, and preview again until you're fully satisfied with your project setup.

This Preview Feature is a game-changer, as it allows you to make informed decisions and tailor your Grails application precisely to your needs. Gone are the days of uncertainty - with the Preview Feature, you can confidently create and manage your Grails projects with ease.

So, what are you waiting for? Try out the Preview Feature on https://start.grails.org and unleash the full potential of the New Grails Forge CLI and UI.

Ready to Forge Ahead

With the New Grails Forge installed on your system, you're all set to embark on a new era of Grails application generation. Explore the lightning-fast performance, enhanced flexibility, and seamless compatibility with Gradle and plugins. Together, let's redefine Grails development and build remarkable applications for a rapidly evolving world.

Introducing the Grails Forge UI: A User-Friendly Gateway to Project Generation

Now, let's move on to the star of the show - the React-based Grails Forge UI! This cutting-edge website serves as an interactive and user-friendly alternative to project generation, eliminating the need to install the CLI locally.

Seamless Replacement for the Old Grails Forge Website

With the Grails Forge UI, we are embracing the future of project creation and bidding farewell to the old Grails Forge website https://start.grails.org. This exciting transition ensures a more advanced and efficient platform for generating Grails projects.

A Leap Towards the Future

The New Grails Forge marks a significant leap towards the future of Grails application generation. With its Micronaut-inspired design, lightning-fast performance, and versatile application-types, you can confidently embark on your development journey, knowing you have a powerful tool at your disposal.

Join the New Grails Forge Revolution

We invite you to embrace the New Grails Forge and be part of this revolutionary movement in Grails development. As we continue to refine and improve, your feedback and insights are invaluable. Together, let's redefine Grails application generation and shape a future of remarkable applications powered by the New Grails Forge.

Stay connected with us on the official Grails website and community forums for the latest updates, resources, and discussions on harnessing the full potential of this cutting-edge CLI. Let's embark on this journey together, unlocking the limitless possibilities of the New Grails Forge.

Happy coding!

The Grails Team

Introducing Grails 6 - Embracing Modern Java, Java 11, and the Latest Spring and Spring Boot Updates

Puneet Behl — Tue, 25 Jul 2023 00:00:00 GMT

The Grails Foundation™ is thrilled to unveil Grails 6, a major release that propels the Framework into an exciting new era of web development. This significant update brings a host of advancements, including embracing modern Java, upgrading to Java 11, a new Grails Forge, and incorporating the latest updates of Spring 5.3.28 and Spring Boot 2.7.12.

Embracing Modern Java and Java 11:

Grails 6 sets a new standard by updating its minimum Java version to Java 11. This empowers developers with the latest language features, performance improvements, and enhanced security offered by Java 11.

Why Java 11 for Now?

The decision to update to Java 11 in Grails 6 was driven by several factors, including Java 11's LTS status, stability, and widespread adoption in the Java ecosystem. Java 11 offers a stable and well-supported environment for Grails applications, aligning with the needs of enterprise users who prioritize a reliable and mature Java version.

The Path to Java 17:

While Grails 6 does not include Java 17 support in this release, we are committed to providing an easy upgrade path for those planning to move to Java 17 in the future. The Grails team is actively planning to include Java 17 support in the next major release, ensuring developers can confidently embrace the latest Java advancements when the time comes.

Latest Spring and Spring Boot Updates:

Grails 6 incorporates the latest updates of Spring 5.3.28 and Spring Boot 2.7.12, bringing a wealth of new features and optimizations. These updates offer performance enhancements, Kotlin Coroutines support, WebSocket improvements, enhanced Actuator endpoints, Micrometer metrics enhancements, Jakarta Persistence integration, and additional configuration properties. By leveraging the power of the latest Spring versions, Grails 6 empowers developers with a cutting-edge development experience.

Updates to Gradle 7.6:

Grails 6 now provides support for the latest Gradle version, 7.6.1, offering developers a more efficient and robust build automation tool. Gradle 7.6.1 brings with it various improvements, enhanced performance, and additional features, further streamlining the development process and ensuring compatibility with the latest libraries and dependencies.

Introducing the New Grails Forge:

Grails 6 not only embraces modern Java and the latest Spring and Spring Boot updates but also introduces the New Grails Forge UI, revolutionizing the web development experience for creating and managing Grails projects. With the New Grails Forge UI, developers can enjoy a modern and efficient user interface with simplified project creation, intuitive navigation, real-time feedback and validation, visual dependency management, enhanced plugin integration, project customization, built-in best practices, and responsive design. This intuitive UI streamlines the development process, making it easier for developers to set up new Grails projects and manage existing ones.

Enhanced Integration of the Micronaut framework with Grails:

The Grails framework has long provided integration with the Micronaut framework, fostering seamless collaboration between the two Frameworks. With Grails 6, we are proud to announce further improvements in this integration, enhancing the developer experience with each major release. Developers can now enjoy even better Micronaut integration, promoting code reuse and reducing redundancy between Grails and Micronaut components. For instance, developers can easily inject Micronaut beans into Grails services, controllers, and other components, gaining access to the Micronaut framework’s extensive ecosystem of features and functionalities.

Another example of the improved Micronaut integration is the ability to utilize the Framework’s declarative client, allowing Grails applications to consume RESTful APIs with minimal boilerplate code. This streamlined approach enhances development efficiency and promotes maintainable, efficient communication between microservices.

Community and Documentation Support:

The Grails community and documentation will play a pivotal role in assisting developers with the upgrade process. As Java 17 support becomes a reality in the next major release, the community will offer valuable insights, best practices, and support to ensure a seamless migration for Grails applications.

Why Update to Grails 6?

Upgrading to Grails 6 offers numerous benefits for developers and product managers alike:

Enhanced Developer Productivity: Grails 6 introduces developer-centric improvements, reducing boilerplate code and simplifying tasks to boost productivity.
Future-Proofed Applications: Grails 6 supports Java 11, ensuring long-term stability and security updates for your applications.
Performance Gains: Leveraging the latest Spring and Spring Boot updates, Grails 6 delivers improved application performance and optimized resource utilization.
Enhanced Integration Possibilities: Grails 6 offers improved Micronaut integration, allowing seamless collaboration between Grails and Micronaut components, expanding your application's capabilities.
Up-to-Date Tooling: With compatibility with Gradle 7.6.1, Grails 6 ensures efficient build automation and compatibility with the latest libraries and dependencies.
Active Community Involvement: Engaging with the vibrant Grails community fosters collaborative learning and development, benefiting all Grails users.
Seamless Migration Path: Grails 6's commitment to providing an easy upgrade path to Java 17 ensures embracing the latest Java advancements without disruption.

Upgrade to Grails 6 today and seize the opportunity to elevate your applications and embark on a journey towards creating innovative and scalable web applications.

Join the Grails Community: A Collective Journey

At the heart of Grails lies its vibrant and passionate community of developers, whose contributions play a pivotal role in shaping the framework's evolution. Community contributions not only enhance the feature set of Grails but also address bugs, provide valuable feedback, and share best practices. The active involvement of the community fosters a collaborative environment where ideas are shared, discussed, and refined, ultimately benefiting all Grails users. With Grails 6, we encourage developers to actively engage with the community, contribute to the project, and together, we can push the boundaries of web development, making Grails an even more powerful and versatile framework.

In conclusion, Grails 6 represents a significant advancement in web development, providing developers with a powerful platform to build exceptional applications. Embrace Grails 6 and its advancements in Java, Spring, Spring Boot, and Micronaut integration to unlock the full potential of modern web development and embark on an exciting journey towards creating innovative and scalable applications.

To download and get started with Grails 6, visit the official Grails documentation: https://grails.apache.org/docs/latest/guide/gettingStarted.html#downloadingAndInstalling.

Happy Coding with Grails 6!

Grails 6 RC1 - Release Announcement

Puneet Behl — Sat, 27 May 2023 00:00:00 GMT

The Grails Foundation is pleased to announce the release of Grails 6 RC1! We encourage you to update your applications to this release.

The Grails 6.0.0-RC1 Release provides an easy upgrade path to the developers, or project managers who are looking to upgrade to Java 17, and Spring 6.

What’s New?

All major Grails libraries such as Grails Views, Grails GSP, Grails Testing Support, GORM core, GORM for Hibernate, MongoDB, and Neo4J are updated to Java 11 as baseline, Gradle 7.6.1.
A brand new and superfast Command Line Interface to generate Grails 6 applications and plugins. This new CLI provides the ability to generate applications completely offline.

Installation

Installing with SDKMan

The easiest way to install the new Grails CLI is with SDKMan, run the following command:

sdk install grails 6.0.0-RC1

Download & Install Binary

Download the latest binary from here based on your Operating System
Extract to appropriate directory.
Create environment variable GRAILS_HOME which points to installation directory, eg: c:/grails
Update the PATH environment variable, append %GRAILS_HOME%\bin.

Use SDKMan To Build & Install From Source

Clone the repository as follows:
git clone github.com/apache/grails-forge/tree/v6.0.0-RC1
Build dist using the command ./gradlew :grails-cli:assembleDist.
Copy & Extract the archive from grails-forge/grails-cli/build/distributions/grails-cli.*.zip to the user home or any other directory of your preference.
Use SDKMan, to install the dev version and use the path to the extracted directory. For example, the following command install the “dev” version and assumes you’ve extracted to the user’s home directory:

sdk install grails dev ~/grails-cli/
sdk use grails dev

Why is my Grails 6 RC1 application not working?

Starting with the recent release of Grails 6, the CLI has moved to a separate project github.com/apache/grails-forge. The CLI shipped with Grails Core is deprecated and will be removed in the near term.
If you have used Grails binaries before, then you might be used to downloading it from the Grails Core release page. However, this will no longer work and you should instead, download the OS specific native image from the Grails Forge 6.0.0-RC1 Release Page.

Why do some Grails commands don't work?

The New CLI currently supports commands like create-app, create-controller, etc. You could also enter the Grails CLI interactive mode by entering grails and pressing the return key for auto-complete of supported commands.

We’ve dropped the support for commands which perform the redundant tasks such as grails run-app and we recommend using the Gradle bootRun task to run your application. However, we’ll add the support for a few other commands such as create-service, create-test, etc.

Grails 4 EOL - Announcement

Grails 4 was released in July 2019. As of March 31, 2023, Grails 4 has reached the end of support. This means Grails version 4.x is unlikely to receive additional updates.

The Grails Foundation is committed to the continued evolution, development, maintenance, and support of the Grails framework. Our goal is to provide Grails users the support they need while maintaining as much focus as possible on innovation. The level and type of support available for earlier versions of the Grails framework will change as the Framework continues to evolve, and the support team remains available to help regardless of the version of the Grails framework that you are using. Please see support options here.

We understand that different organizations have different support needs. With our support options, we can help your team make the most of the features available in the Grails framework and add another layer of protection to the investment in your critical business applications. Commercial Support if you need help supporting your Grails applications.

Grails Roadmap

The new Grails Forge website is coming soon!
More application types will be supported.
We will be adding more features such as Security.
The Grails Scaffolding Plugin will be updated to work with Grails 6.

Grails 6 M2 - Release Annoucement

Puneet Behl — Wed, 29 Mar 2023 00:00:00 GMT

The Grails Foundation is excited for the release of Grails framework 6 M2! We encourage you to try this release and provide your feedback here.

What are some changes to expect?

Leveling up the Grails CLI
New Java 11 Baseline

With the release of Grails 6 M2, we have introduced a brand new implementation of the Grails Command Line Interface (CLI) inspired by the CLI used in the Micronaut framework. This new CLI is much more flexible, fast and easy to maintain. Using the new CLI, you can create Grails applications offline or in areas of limited connectivity, and it is lightning fast. It uses Picocli for building the command-line application, and the Rocker template engine which produces statically typed plain Java objects.

Key CLI Concepts

Application Type

An application type can be defined as a pre-selected group of features required at minimum to build a specific type of application. For example - a Grails web application is shipped with features such as GSP, Geb, Webdriver, etc.
Features

A feature affects the outcome of a generated project such as adding dependencies to build.gradle file, some default configurations, support additional CLI commands, etc.

Starting with Grails 6, there will not be a Grails CLI wrapper in new projects. Many of the commands offered by the legacy CLI can be run directly from Gradle. For example, ./grailsw run-app can be achieved with ./gradlew bootRun. For commands that alter the files of a Grails project like create-controller, you will be able to use the globally-installed Grails CLI from within the project folder.

There are some specific commands which are supported via plugins that may not work with the New CLI, these commands are written as Groovy scripts and need to be converted to Grails ApplicationCommand which would make them available as Gradle tasks. You can find more information in the Grails Documentation about creating custom commands. Alternatively, we can rewrite commands in the New Grails CLI and use rocker templates instead.

Installation

Installing with SDKMan

The easiest way to install new Grails CLI is with SDKMan, run the following command:

sdk install grails 6.0.0-M2

Download & Install Binary

Download the latest binary from here based on your Operating System
Extract to appropriate directory
Create environment variable GRAILS_HOME which points to installation directory, eg: c:/grails
Update the PATH environment variable, append %GRAILS_HOME%\bin

Use SDKMan To Build & Install From Source

Clone the repository as follows:

git clone https://github.com/apache/grails-forge.git

Build dist using the command ./gradlew :grails-cli:assembleDist
Copy & Extract the archive from grails-forge/grails-cli/build/distributions/grails-cli.*.zip to the user home directory
Use SDKMan, to install dev version using the following command:

sdk install grails dev ~/grails-cli/
sdk use grails dev

The Previous Grails CLI & Its Limitations

The previous Grails CLI used YAML based configuration files which are not very extensible when it comes to customizing it. Also, it was very difficult to use automation tools to auto-update dependencies and the process of testing the profile was very complicated.

The Grails Profiles & ApplicationType in the New CLI

The Grails Profiles such as web, plugin, react, etc. are supported by means of application-types. Currently, we support following application-types:

Web
REST API
Web Plugin
Plugin

We will soon add support for REST API Plugin, ReactJS and AngularJS application types.

The Grails Scaffolding Plugin

The Grails Scaffolding plugin, which defines commands such as generate-all and generate-controller, will not work because it uses the command scripts. In Grails 3, we introduced the concept of an ApplicationCommand which has similar abilities as scripts in regards to retrieving arguments, template generation, file access, and model building. For more information, please read the Grails documentation for creating custom commands.

Why should you upgrade to Grails 6?

With the future release of Grails 7, we are planning a move to Java 17 as a baseline, so Grails 6 provides an easy upgrade path to users or applications who are planning to move to Java 17.
We will be ending the support for Grails 4 by the end of this quarter, and Grails 5 by the end of 2023. We strongly recommend updating applications to upgrade to Grails 6.
Additionally with this realease, we have updated a bunch of underlying dependencies. Some of those updates include: Spring 5.3.26, Spring Boot 2.7.9, Tomcat 9.0.73, and Hibernate 5.6.15.Final. Check the Grails Core GitHub release notes page for more information.

Grails 6 Release Schedule

We will work on updating other important Grails projects such as GORM, GSP, Views etc to Grails 6 M2 over the next few days.
Grails 6 RC1 will be released in the next couple of weeks which will include updates to GORM, GSP, and Grails Views.
Based on feedback, Grails GA or another RC release is targeted for the end of April.

Grails Support Schedule

We will end support for Grails 4 by the end of this quarter (31st March 2023). End of support means that this version of the Grails framework is no longer actively maintained and is unlikely to receive additional updates. You can still recieve commercial support through our additional support options here.
We will support Grails 5 through the end of 2023.

The Road Ahead..

The new Grails Forge website is coming soon!
More application types will be supported.
We will be adding more features such as Security.
There will be support for the Grails Scaffolding Plugin with Grails 6.
We are planning the move to Java 17 baseline, support Apache Groovy 4, Spring 6, and Spring Boot 3 as part of Grails 7.

Thank you!

Big thanks to our wonderful community of users for your continued support of the Grails framework over the past 15 years! With a hopeful outlook towards the future and a deep sense of gratitude, we eagerly anticipate the path that lies ahead, embracing the invaluable chance to develop and pioneer new advancements within this Framework.

Grails Foundation joining Unity

Jen Wiese — Fri, 17 Mar 2023 00:00:00 GMT

The Grails Foundation™ is pleased to announce a new partnership with the Unity Foundation™.

The Grails Foundation is one of three Open Source Software (OSS) Foundations joining the Unity Foundation as official member organizations of the Unity team. Established in 2020 as a non-profit, community-based organization, Unity set out on a journey to leverage open source software tools to provide more inherently equitable access to the information and services that support the needs of the greater St. Louis area community, with a focus on the underserved.

Dr. Ebrahim Moshiri, founder of St. Louis-based technology company, Object Computing, Inc. (OCI), envisioned a radically new way of serving the community by extending all of the openly available tools and systems that OCI had been building, supporting, and advancing for the last three decades. The Unity Foundation was organized to drive the engineering of a new kind of CommUNITY Infrastructure and data sharing ecosystem that, through collaborations and partnerships with other St. Louis based organizations, can address the digital divide in our region. In essence, Unity seeks to apply the ideals of altruism, benevolence, and social consciousness to the world of software tools and systems that organizations use to collect, organize, and share data.

As a commitment to reusable and interoperable technologies to facilitate greater access and capability for all users, OCI made significant investments in establishing three OSS product Foundations - the Grails Foundation™, the Micronaut Foundation™, and the OpenDDS Foundation™. These non-profit entities are solely focused on ensuring the continuity and sustainability of our OSS products. Today, thousands of software engineers, researchers, and end users around the globe use and contribute to these trusted tools and platforms, including organizations like Microsoft, Amazon, Oracle, and Google. Moving the Grails Foundation under Unity provides a meaningful alliance between Unity and our amazing community. We are excited for the opportunity to work closely with Unity to further develop an open source technology infrastructure and ecosystem supporting our underserved communities. Unity will continue its commitment to serve as an OSS aggregator, and will scale community participation in helping define, advance, and contribute to the ongoing success and sustainability of the Grails framework.

In January 2023, Object Computing and the Unity Foundation together pledged an additional $2M to the Grails Foundation for the ongoing benefit and advancement of the Grails framework. As the proud steward of the Grails Foundation, Unity continues its commitment to innovative collaboration with community partners with a deep desire to build and contribute to a new CommUNITY infrastructure - one that will be engineered for equity, accessibility, enrichment, and compassion for those who need it most.

To learn more about the Unity Foundation, click here.

To learn more about how you or your organization can support the Grails Foundation!

Grails Artifact Repository Scheduled Maintenance

Jason Schindler — Wed, 08 Feb 2023 00:00:00 GMT

Scheduled Maintenance of repo.grails.org Feb 12, 2023 08:00 UTC - 11:00 UTC

The Grails Artifactory Instance at repo.grails.org will be down for scheduled maintenance on Sunday February 12th, 2023 as JFrog migrates it to newer infrastructure.

The outage will begin at 08:00 UTC and is expected to last 3 hours. The repository should be available again at 11:00 UTC

During this time, projects that retrieve their dependencies from repo.grails.org may experience issues.

For more information, or to discuss issues encountered after this window, please see this GitHub issue.

Grails Spring Security Core Plugin Improper Privilege Management Vulnerability

Matthew Moss — Tue, 22 Nov 2022 00:00:00 GMT

Information regarding CVE-2022-41923

Overview

The Grails team has confirmed a security vulnerability found in the Grails Spring Security Core plugin, initially identified by Adrien Peter and Benjamin Sepe from Synacktiv, and investigated and reported by Arek Bazylewicz of ID5. This vulnerability has been assigned identifier CVE-2022-41923.

The vulnerability allows an attacker access to one endpoint (i.e. the targeted endpoint) using the authorization requirements of a different endpoint (i.e. the donor endpoint). In some Grails framework applications, access to the targeted endpoint will be granted based on meeting the authorization requirements of the donor endpoint, which can result in a privilege escalation attack.

Update: Synacktiv has made available their security advisory (PDF) on this vulnerability.

Impacted Applications

Grails Spring Security Core plugin versions:

1.x
2.x
>=3.0.0 <3.3.2
>=4.0.0 <4.0.5
>=5.0.0 <5.1.1

We strongly suggest that all Grails framework applications using the Grails Spring Security Core plugin be updated to a patched release of the plugin.

Protecting Your Applications

The following Grails Spring Security Core plugin versions have been patched for this vulnerability:

The best way to protect your Grails framework application is to upgrade to a patched release of this plugin.

If you are unable to upgrade to a patched version of the plugin, you can work around the issue with a small code and configuration change described in this GitHub repository. We have provided workaround examples for Grails framework 2 through 5 applications. A demonstration of the vulnerability will be provided in time, after users have an opportunity to patch their applications.

Looking Forward

The Grails Foundation and the Grails development team take application security very seriously. We are continuing to research and monitor this vulnerability and will update this post with new information as it is discovered.

If you have questions about this vulnerability or need assistance on upgrades or workarounds, please see the discussion on GitHub or contact us at security@apache.org.

Grails Data Binding to Static Properties Bug

Matthew Moss — Wed, 28 Sep 2022 00:00:00 GMT

Information about an issue in the Grails data binding logic that can cause modification of static properties

Summary

The Grails Team has confirmed a bug that was found in the Grails data binding logic, which incorrectly permits data binding to static properties under certain conditions. This bug was identified and reported by the Engineering Team at Transitional Data Services (https://tdsi.com).

Description

Data binding to static properties is not intended behavior. However, because of this bug, a static property of the target object's class may be modified if:

The data binding source contains a property of the same name as the static property
The static property's declared type is Object (or the type is undeclared, which is the same as declaring as Object)
The static property is not final

This can occur when manually calling bindData (or one of several variants) given the conditions above. Under particular additional conditions, controller actions that automatically bind request data to (nested) command objects may cause static properties to change.

The constraints property

One common property that represents an important part of the functionality in the Grails framework is the constraints property. The constraints property allows classes that implement the Validateable trait to check that the data in an instance of the class is valid. It is also a static property that could be overwritten due to this bug, potentially leading to data corruption. Because of this possibility, we feel it is important for organizations using the Framework to be aware of this bug and its resolutions.

For more information about data validation functionality available in the Grails framework, please see the documentation.

Resolution

The Grails Team recommends that all Grails applications be upgraded to a patched Grails release. Grails 4.x applications can be upgraded to version 4.1.2 or higher, and Grails 5.x applications can be upgraded to 5.2.3 or higher.

We have released a patched version of Grails 3 for this bug. Grails 3.x applications can be upgraded to version 3.3.16.

Please note that versions 1, 2, and 3 of the Grails framework have reached end of support. We strongly recommend that applications built with these versions be upgraded to an actively maintained version of the Framework. Additionally, the Grails Foundation provides Commercial Support options for Grails framework versions 3, 4, and 5.

If you are unable to upgrade to a patched version of the Framework, you can make a couple of minor adjustments to work around the issue.

First, if your application makes explicit calls to bindData, those calls should be reviewed and adjusted to avoid binding to static properties of the target instance's class.

Second, you can prevent data binding to static properties by marking them as final. For example:

class RecordValueCommand implements Validateable {
    int value
    static constraints = { value min: 0 }
}

Because constraints is not final and has no declared type, it is susceptible to this data binding bug. The workaround is to add the final modifier.

static final constraints = { value min: 0 }

In situations where the final modifier cannot be added, the type of the property should be declared explicitly (not Object) and the static property will resist type-changing modifications.

static Closure constraints = { value min: 0 }

Thank you!

We would like to thank the Engineering Team at Transitional Data Services for identifying this bug as well as the countless contributions from the folks in our awesome community. Without your dedication and enthusiasm, the Grails framework would not be where it is today. Thank you!

For more technical details about this bug and the patches, please see the discussion on GitHub.

Grails Framework Remote Code Execution Vulnerability

Puneet Behl and Jason Schindler — Mon, 18 Jul 2022 00:00:00 GMT

Grails Framework information regarding CVE-2022-35912

Updates

July 20th, 2022

Updated impacted Grails framework versions.

Overview

The Grails team has confirmed a critical security vulnerability reported by meizjm3i and codeplutos of AntGroup FG Security Lab. This vulnerability has been assigned identifier CVE-2022-35912.

The vulnerability allows an attacker to remotely execute code within a Grails application runtime by issuing a specially crafted web request that grants the attacker access to the class loader. This attack exploits a section of the Grails data-binding logic. Grails data-binding is invoked in a number of ways including the creation of command objects, domain class construction, and manual data binding when using bindData. For a full description, please refer to the data-binding documentation.

Impacted Applications

Grails framework versions
- >= 3.3.10 & < 3.3.15
- >= 4.0.0 & < 4.1.1
- >= 5.0.0 & < 5.1.9
- 5.2.0
Running on Java 8
Using embedded Tomcat runtime, as well as those deployed to a Servlet Container

We have confirmed this vulnerability on Grails framework versions 3.3.10 and higher (including Grails framework 4 and 5) that are running on Java 8. The vulnerability has been observed in both the embedded Tomcat runtime and applications deployed as a war to a Tomcat instance.

Due to the nature of this vulnerability, we strongly suggest that all Grails applications, including those that are not vulnerable to this specific attack, be updated to a patched Grails release. While we have not been able to reproduce this specific exploit on applications running in Java 11 or in versions of the Grails framework before 3.3.10, the nature of the vulnerability is such that variations on the attack could be discovered that earlier Grails releases, and Grails applications running on higher versions of Java, will be impacted.

Protecting Your Applications

The following Grails framework versions have been patched for this vulnerability:

5.2.1
5.1.9
4.1.1
3.3.15

The best way to protect your Grails applications is to upgrade to a patched release of the framework.

Grails 4.x applications can be upgraded to version 4.1.1 or higher, and Grails 5.0.x and 5.1.x applications can be upgraded to 5.1.9 or higher, and Grails 5.2 applications can be upgraded to 5.2.1 or higher.

Protecting Grails 3 Applications

For Grails 3 applications, we have released Grails framework 3.3.15, which includes a patch for this vulnerability (please note that Grails framework version 3 has reached end of support, and we strongly recommend that all Grails 3 applications be upgraded to an actively maintained version of the framework).

Protecting Grails 2 Applications

As mentioned above, this specific attack is enabled by code added in version 3.3.10 of the Grails framework, so Grails framework version 2 applications are not vulnerable to it. Due to the nature of the exploit, we strongly suggest that you upgrade your Grails applications to a patched and supported version of the framework. Grails framework version 2 has reached end of support.

Next Steps

The Grails Foundation and the Grails core development team take application security very seriously. We are continuing to research and monitor this vulnerability and will update this post with new information as it is discovered.

Announcing Our Newest Tools and Infrastructure Partner: JetBrains

Jen Wiese — Fri, 01 Apr 2022 00:00:00 GMT

We're pleased to announce that JetBrains has joined the Grails Foundation as a Tools and Infrastructure Partner.

The Grails Foundation™ is truly appreciative of the tremendous support we receive from our sponsors. In addition to financial support, generous contributions of development tools, infrastructure, and other resources are essential to the continued evolution of the Grails® framework. Our Tools and Infrastructure Partnership program recognizes the companies whose contributions enable us to maintain and expand both the open source technologies and the assets we rely on to keep our communities informed and engaged.

Today, we are pleased to announce that JetBrains, producer of IntelliJ IDEA, has joined the Grails Foundation as a Tools and Infrastructure Partner! In support of our organizations' shared values and goals within the open source ecosystem, JetBrains generously provides the Foundation with licenses to their incredible suite of products for our core development team!

As many Grails developers already know, the ultimate edition of IntelliJ IDEA includes first-class support for the Grails Framework, as well as a host of features to increase developer productivity across a multitude of languages and frameworks. Those features help the Foundation's core development team do the necessary work to bring the open source Framework to the community.

We’re delighted to have JetBrains on board as a Tools and Infrastructure Partner. The JetBrains team's support for and excitement about Grails technology over the years has been tremendous. Their engagement in our community has been awesome, and we look forward to continued collaboration in the years to come. We truly appreciate the dedication and passion JetBrains has for open source projects. On behalf of the Grails Foundation, thank you! Initiatives like these that support and grow our Framework are the kinds of things we look for in a lifelong technology partner.

The Grails Foundation is a not-for-profit organization that supports the Grails framework. The Foundation not only builds and supports an ecosystem of documentation, functionality, and services, it promotes and evangelizes the Framework as a leading technology in the JVM space. The generous support of our Corporate Sponsors allows the Foundation to continue to ensure technical innovation and advancement of the Framework as a free and open public-use software development toolkit for our growing global community.

To learn more about how you or your organization can help support this Foundation, please check us out!

Grails and the Recent Spring Framework RCE

Jason Schindler — Thu, 31 Mar 2022 00:00:00 GMT

Grails Framework information regarding CVE-2022-22965

Background

The Spring Framework Team recently announced a remote code execution vulnerability, published as CVE-2022-22965, discovered within the Spring Framework. At this time, there is a known exploit that impacts applications that:

Use JDK 9 or higher
Run on the Apache Tomcat Servlet container
Are packaged as a WAR, and
Include the spring-webmvc or spring-webflux dependency

More up-to-date information can be found on the Spring Blog announcement.

Are Grails Applications Vulnerable?

Because Grails applications are built on top of Spring and Spring Boot, the Grails team has taken this vulnerability very seriously. Our investigations have yielded no evidence that Grails 4.x or 5.x applications are vulnerable to this attack. The Grails framework has its own data-binding logic, which includes checks to validate that a given property a) is in a list of properties that may be bound to, and b) exists within the target metaClass. All other property candidates are ignored.

The known exploit is one mechanism that can be used for this vulnerability. We will continue to monitor this situation and alert the Grails community of any vulnerabilities discovered, along with mitigation steps.

Next Steps

Although at this time, we have no reason to believe that Grails applications are vulnerable, as a precaution, we have released Grails 5.1.6. This Grails Framework release updates our Spring dependency to 5.3.18, which includes the upstream patch from the Spring Framework Team.

2GM Town Hall Meeting: 2022 Q1

Jen Wiese — Fri, 07 Jan 2022 00:00:00 GMT

A big thanks to everyone who joined us for our Q1 2GM Town Hall Meeting! For those of you who missed the live event, the recording is embedded below.

At this quarter’s meeting, we provided an update on the latest advancements with the Grails and Micronaut frameworks, including a look at what is coming soon. We also shared the latest news and sponsors of the Grails and Micronaut Foundations, as well as some great live discussions and Q&A with our panel.

A special thanks to our fantastic panel of experts: James Kleeh, Puneet Behl, Sergio del Amo Caballero, and our awesome guest Cédric Champeau.

Till next time!

— Jen Wiese

Introduction to Grails Security

Grails Foundation Announces First Tools and Infrastructure Partner

Jen Wiese — Fri, 07 Jan 2022 00:00:00 GMT

Gradle has joined the Grails Foundation as our first Tools and Infrastructure Partner

The Grails Foundation™ is truly appreciative of the tremendous support we receive from our sponsors. In addition to financial support, generous contributions of development tools, infrastructure, and other resources are essential to the continued evolution of the Grails® framework. Thus, we have established a new partnership program to recognize the companies whose contributions enable us to maintain and expand both the open source technologies and the assets we rely on to keep our communities informed and engaged.

Today, we are pleased to announce that Gradle Inc, the providers of Gradle Build Tool and Gradle Enterprise, has joined the Grails Foundation as our first Tools and Infrastructure Partner! In support of our organizations' shared values and goals within the open source ecosystem, Gradle provides the Foundation free instances of Gradle Enterprise.

Gradle Enterprise has helped our team to improve build times and test-feedback cycle times, and improve troubleshooting efficiency by combining root-cause analysis data with failure analytics.

We’re delighted to have Gradle on board as a Tools and Infrastructure Partner. The Gradle team's support and excitement for the Grails technology over the years has been tremendous. Their engagement in our community has been awesome, and we look forward to continued collaboration in the years to come. We truly appreciate the dedication and passion Gradle has for open source projects. On behalf of the Grails Foundation, thank you! Initiatives like these that support and grow our Framework are the kinds of things we look for in a lifelong technology partner.

To learn more about how you or your organization can support this Foundation, please check us out!

Grails Framework 5.1 Released

Puneet Behl — Sat, 18 Dec 2021 00:00:00 GMT

The Grails Foundation™ is pleased to announce a new minor release: Grails framework 5.1!

This release of the Grails framework includes a number of bug fixes and Gradle 7.2 compatibility changes (the Gradle task definitions with incorrectly defined input output will now fail the build), plus a bunch of dependencies updates. For more information, please check the Grails 5.1 release notes.

Updated Dependencies

The dependencies that have been updated include:

Spring Boot 2.6.1

One important change that accompanies Spring Boot 2.6 is that circular references are prohibited. In order to maintain backwards compatibility for Grails users, Grails framework 5.1 explicitly enables circular references by default. This will no longer be the case once Grails framework 6 is released. For more information check the Spring Boot 2.6 Release Notes.

Micronaut 3.2

Updating to Micronaut 3.2 should not affect Grails applications. Please check the release notes for more details.

GORM for Hibernate 7.2, which updates to Hibernate 5.6

This version updates to Hibernate ORM 5.6.2. There are several other bug fixes and dependency updates. For complete details, please check the release notes for GORM for Hibernate 7.2.

GORM for MongoDB 7.2, which updates to underline Mongo driver 4.4

This version updates the underlying Mongo driver to 4.4. Read What's New — MongoDB Java Sync 4.4 to understand what has changed in the Java driver. We also recommend that you check the release notes for GORM for MongoDB 7.2 for a list of all the changes and dependency updates.

GORM for Neo4j

Please check the release notes for complete information about the changes in this release.

A Note About Semantic Versioning

Grails framework 4 was the first version of the Framework that followed semantic versioning. Grails framework 5.1.0 is a minor release; thus, it should not contain breaking changes. It contains new features, the patches introduced in Grails 5.0.x releases, and minor upgrades to Grails dependencies, such as Spring Boot, Micronaut, and GORM. Please upgrade quickly to get the latest updates into your Grails 5 applications.

Upgrading to Grails Framework 5.1

As this is a minor release, updating to Grails framework 5.1 should be pretty straightforward. Here are step-by step instructions:

In your gradle.properties file,

Update property grailsVersion to 5.1.0
Update property gorm.version to 7.2.0

In your build.gradle file

Update Gradle hibernate5 plugin to 7.2.0
Under dependencies, update hibernate-core to 5.6.2.Final

The Road Ahead

Spring Security Core Plugin

Currently, the Spring Security Core Grails plugin still uses Spring Security Core 5.1.13.RELEASE which is EOL. We are planning to update the plugin to use the latest version of Spring Security. See Spring Security Versions · spring-projects/spring-security Wiki · GitHub for more information.

Leveling up the Grails CLI!

The current implementation of Grails CLI is difficult to test and unadaptable. For example, configuring automation tools to update dependencies is impossible. Also, the CLI does not work offline, and it is very difficult to customize it. We plan to work on implementing a new, super-flexible, easy-to-customize CLI that eliminates these limitations.

Consolidating Grails Plugins

Currently, Grails plugins are distributed across multiple Github organizations, including gpc - Grails Plugin Collective · GitHub, Grails Plugins · GitHub, and grails3-plugins · GitHub. We are planning to consolidate a list of all active plugins into one place. We will soon share more information about this initiative in the Grails blog.

Need help upgrading to Grails® framework 5.1?

We are excited about the release of Grails framework 5.1 and look forward to hearing about your experience with it. Please feel free to reach out to us if you have any questions or need help updating your applications. Community members and members of the core development team are available to answer questions on our Slack channel, and hourly commercial support can be purchased here.

Grails Framework and Log4j 2 Vulnerability

Sergio del Amo — Tue, 14 Dec 2021 00:00:00 GMT

Vulnerability CVE-2021-44228 may allow an attacker to remotely execute code. It affects Log4j's log4j-core jar. Log4j v2.15.0 fixes it. Moreover, Log4j v2.16.0 disables JNDI functionality by default, and it removes message lookups. Log4j v2.17.0 addresses CVE-2021-45105. It protects against infinite recursion in lookup evaluation.

Are Grails 2 applications vulnerable?

CVE-2021-44228 only affects log4j versions between 2.0 and 2.14.1. Grails 2 applications used Log4j 1.x. However, you should consider migrating as soon as possible to the latest version of the Grails framework. Grails 2 is EOL (End of Life).

Are Grails applications (3, 4, or 5) vulnerable?

All Grails applications built on Grails framework 3.0.0 and later use Logback. Thus, most Grails applications are not affected.

However, your application might be vulnerable if it includes untrusted input in the log messages and pulls log4j-core as a transitive dependency through some other library or a plugin.

The "tomcat-embed-logging-log4j" dependency

You might have noticed that there is a tomcat-embed-logging-log4j dependency in the classpath. We believe it is not affected by the vulnerability because:

The JAR does not contain org/apache/logging/log4j/core/lookup/JndiLookup.class.
The POM does not mention any dependencies.

How can you check to see if you are pulling `log4j-core` as a transitive dependency?

If you are using Gradle, the following command will return a dependency report for 'log4j-core' dependency:

./gradlew dependencyInsight --dependency log4j-core

For Grails 2 applications, use:

./grailsw dependencyReport

How do you tell your build to use a particular version of Log4j?

With Gradle, if your application is pulling log4j-core transitively, you can declare a resolutionStrategy:

configurations.all {
  resolutionStrategy.eachDependency { DependencyResolveDetails details ->
    if (details.requested.group == 'org.apache.logging.log4j') {
      details.useVersion '2.17.0'
    }
  }
}

Other Options

If you cannot upgrade, please do the following, as suggested by the Log4j team:

For those who cannot upgrade to 2.15.0, in releases >=2.10, this behavior can be mitigated by setting either the system property log4j2.formatMsgNoLookups or the environment variable LOG4J_FORMAT_MSG_NO_LOOKUPS to true. For releases >=2.7 and <=2.14.1, all PatternLayoutpatterns can be modified to specify the message converter as %m{nolookups} instead of just %m. For releases >=2.0-beta9 and <=2.10.0, the mitigation is to remove the JndiLookup class from the classpath: zip -q -d log4j-core-*.jar org/apache/logging/log4j/core/lookup/JndiLookup.class.

Learn More

All Grails applications built on Grails framework 3.0.0 and later are Spring Boot applications. Learn more about Log4j 2 vulnerability and Spring Boot in the Spring blog.

Grails Training Now Enrolling

Jen Wiese — Tue, 07 Dec 2021 00:00:00 GMT

Our first training workshops for 2022 have just been added to the schedule!

Courses are developed and delivered by team members who work daily with these advanced technologies and can speak with authority as subject matter experts.

February 14 & 15, 2022

Learn how to build robust security functionality into your Grails apps and practice configuring and using such plugins as Spring Security Core, LDAP, REST, ACL, and UI.

Using Micronaut Features in a Grails Application

February 16 & 17, 2022

Learn how to take advantage of the Grails framework's built-in Micronaut features to enhance their productivity and application performance.

Grails Database Migration 4.0.0-RC1 Released

Puneet Behl — Tue, 23 Nov 2021 00:00:00 GMT

The Grails Database Migration plugin is one of the most popular plugins in the Grails ecosystem. It helps manage database changes in a structural manner and prevents inconsistencies, communication issues, and other problems.

In today's technology landscape, where application and database schemas are continuously evolving, this plugin makes it easy for the development team to keep track of database changes, quickly rollback, and modify the schema.

The plugin internally uses the Liquibase library to manage the database. When using the plugin, database migrations are represented in the form of text, either using Groovy DSL or native Liquibase XML, in one or more changelog files. There are several popular approaches to maintaining and organizing the changelog files. We suggest you check Grails Database Migration plugin documentation for details.

In this release, we have updated to Liquibase 4.6, Grails framework 5, and Apache Groovy 3. Refer to the release notes for 4.0.0-RC1 for more details.

Upgrading from Liquibase 3.10 to 4.6

The update from Liquibase 3.10 to 4.6 has been a major effort, and it's allowed us to offer users a bunch of new features, significant improvements, and bug fixes. Following are some highlights:

The extension classes are now loaded with the java.util.ServiceLoader system instead of the legacy custom class-finding logic. This might not impact the main Liquibase functionality, but it will affect anyone using extension classes.
Logging is now based on java.util.Logging, which is unlikely to directly impact applications.
Support has been added to enable users to connect to Liquibase Hub (hub.liquibase.com). This allows you to organize, monitor, and visualize Liquibase database change activity in real time.
Support has been added for additional databases, such as CockroachDB and Maria DB.
We've made significant changes to some important configuration and command APIs and added a new CLI library.
Newly added support for Liquibase Quality Checks allow you to run checks against changelogs and SQL scripts.

For more information, we recommend checking out Liquibase Extension Upgrade Guide and the release notes for each major version starting with 4.x (4.1, 4.2, and so on up to 4.6).

Still Not Updated to Grails Framework 5?

We are excited about the recent release of Grails framework 5 and continually updating documentation and popular libraries. Now is a good time to update to Grails framework 5 and switch to Liquibase 4.

We would love to hear about your experience with the update to Grails Database Migration 4.0.0-RC1, and if you need any help with your upgrade, we're here to support you.

Grails® 5 - Groovy Podcast Episode 84

Sergio del Amo Caballero — Thu, 11 Nov 2021 00:00:00 GMT

Tags: #podcast

Ken Kousen (Java Champion, NFJS speaker, serial book author) invited Puneet Behl (Grails Framework Development Lead) and Sergio del Amo (2GM Developer Advocate) to join him for the latest episode of the Groovy Podcast.

This episode covers Grails framework 5, migrating from Grails framework 2 to Grails framework 5, Grails infrastructure, Micronaut framework integration with Grails framework, and more.

Listen to it in your favorite Podcast Player

Show Notes

Grails framework 5 GA Released

Puneet Behl — Mon, 11 Oct 2021 00:00:00 GMT

The Grails Foundation™ is excited to announce the GA release of Grails framework 5!

Overview

This release includes Apache Groovy 3, Micronaut framework 3, Gradle 7, Spring Boot 2.5, Spring framework 5.3, and Spock 2.0.

Apache Groovy 3

Apache Groovy 3 is a major highlight of this release. It comes with a brand new Parrot parser and a bunch of new features and capabilities.

The Parrot parser supports additional syntax and language features, such as lambda expressions, default methods with interfaces, and a lot more. In addition, several new extension methods are added to existing Java classes. See the release notes for Groovy 3.0 for details.

Grails framework 5 is built with Groovy 3.0.7, which requires JDK 8 as the minimum version of JRE. We have tested most Grails projects up to JDK 14.

Spring Upgrade

Grails framework 5 updates to Spring 5.3.10 and Spring Boot 2.5.5. We strongly recommend checking the following Spring technologies release notes for more information.

Important Changes

Deprecating ‘dot’-Based Navigation

The ‘dot’-based navigation to Grails config is deprecated and will be removed in future.

We request that you update your plugins to use configuration beans @ConfigurationProperties or @Value, or access configuration settings using grailsApplication.config.getProperty(‘a.b.c’, String) instead of grailsApplication.config.a.b.c.

Default Autowire By Type in Data Services

In previous versions, the beans inside the Grails DataService were autowire by name, but this is changed to autowire by type in Grails framework 5. Use the Spring @Qualifier annotation to autowire by name. For details, see the Spring documentation for Fine-tuning Annotation Based Autowiring with Qualifiers.

Grails Gradle Plugin

The Grails Gradle Plugin is moved out of grails-core and may follow separate versioning, so you should decouple the grailsVersion Gradle property from grailsGradlePluginVersion in existing applications.

Grails Gradle Publish Plugin Removed

The Grails Gradle Publish plugin used the Bintray API to publish artifacts. However, after the JFrog shutdown of Bintray, this stopped working. We have removed this plugin from the new Grails Plugin applications.

Get Started with Grails Framework 5

Download

The easiest way to get started is to use SDKMAN! (The Software Development Kit Manager) to download Grails framework 5.0.0. Alternatively, you can download the Grails binary directly from Download Page.

Upgrade

For applications on Grails framework 4, it should be an easy upgrade, as there are not many API changes in Grails framework 5. Also, most Grails framework 4 plugins should work just fine, unless they are using specific Spring, Spring Boot, or Groovy APIs that have been changed or removed.

For members of the Grails plugin community, now is the time to upgrade your plugins and verify they continue to work.

The Road Ahead

In the upcoming months, we will be working on improvements in the Grails CLI, Grails Guides, and the Grails documentation around Micronaut integration.

Thank You

Community involvement is vital for the success of Grails framework. We appreciate the Grails community for the support and feedback throughout this journey. We are excited about this latest release. Please, upgrade your applications to Grails framework 5. We would love to hear about your experience, and if you need any help with your upgrade, we are here to support you.

New Developer Advocate Announced

Jen Wiese — Fri, 08 Oct 2021 00:00:00 GMT

The Micronaut and Grails Foundations™ are excited to announce that Sergio del Amo Caballero has taken on a new role and new responsibilities as the 2GM Developer Advocate!

The Foundations support the technical innovation and advancement of the Grails^® and Micronaut^® frameworks for our growing global community, and the creation of this new position is one more way we are investing in the continued success of our open source products. As Developer Advocate, Sergio will represent developer interests while engaging with our communities to evangelize the Frameworks.

In seeking the right person to fill the Developer Advocate position, we looked for an individual with passion for the technology who also has a strong connection with both the development team and the community at large.

"Sergio has been a major contributor to Grails and Micronaut for years. He is well known and respected in the community and is passionate about sharing information with others. I'm so excited about Sergio taking on this role and can't wait to see all of the ways that our OSS communities grow and evolve over the coming months and years."

—Jason Schindler, 2GM Team Manager

Sergio discovered the Grails framework ten years ago and has been a core member of the 2GM (Groovy, Grails, and Micronaut) team at Object Computing, Inc. (OCI) since 2017, during which time he has been instrumental in efforts to enhance and refine the Frameworks. He has also established a strong rapport with community members through his leadership of Guides publication, regular speaking engagements at events around the world, his personal blog, the Groovy Calamari newsletter, and his enthusiasm for leading educational webinars and training courses on behalf of OCI. Sergio steps into his new position with many ideas to help expand the Frameworks' web presence and accessibility to a larger audience.

"There are still many things that we can do to improve developer experience with the Frameworks, from people just discovering them to teams using them in their production applications. I think this is what the Frameworks need, and I have ideas about how we can support the community. This new role will allow me to do that. I'm excited about helping users unleash their productivity. The community will fulfill the rest of the deal by building amazing applications," said Sergio.

“Sergio's strength as a technologist is matched by his genuine passion for the community. He really and truly embraces our core principle, All Of Us Is Better Than Any Of Us. His taking on this role is a tremendous win for the technology and for the community.”

—Jeff Scott Brown, Object Computing Partner, Grails and Micronaut Foundation Co-Founder

Please join us in congratulating Sergio, and stay tuned for the exciting projects he's already started developing for the community!

2GM Q3 Town Hall Meeting: 2021 Q3

Jen Wiese — Fri, 24 Sep 2021 00:00:00 GMT

A big thanks to everyone who joined us for our Q3 2GM Town Hall Meeting! For those of you who missed the live event, the recording is embedded below.

At this quarter's meeting, we provided an update on the latest advancements with the Grails and Micronaut frameworks, including a look at what is coming soon. We also shared the latest news and sponsors of the Grails and Micronaut Foundations, as well as some great live discussions and Q&A with our panel.

A special thanks to our fantastic panel of experts: Jeff Scott Brown, James Kleeh, Puneet Behl, Sergio del Amo Caballero, and our awesome guest Tim Berglund.

Till next time!

— Jen Wiese

Webinar: An Insider's Guide to Groovy 4

Jen Wiese — Fri, 17 Sep 2021 00:00:00 GMT

Apache Groovy 4 is nearing release, and it's been improved in a number of areas for greater simplicity and efficiency.

Join Object Computing Groovy Practice Lead, Paul King, as he shares an overview of the exciting new features you'll find in Groovy 4, including JDK17 support, switch expressions, annotations on type parameters, enhanced ranges, and support for sealed classes, records, and language-integrated queries. He'll also introduce you to Groovy 4's additional bundle type checkers, macro methods, and design-by-contract support so you can specify preconditions, postconditions, and invariants.

This complimentary 60-minute webinar prepares Groovy users of all proficiency levels to take advantage of the new features Groovy 4 offers.

2GM Q3 Town Hall Meeting Coming Soon

Jen Wiese — Wed, 15 Sep 2021 00:00:00 GMT

Our 2021 third-quarter Town Hall Meeting is just around the corner!

2GM Town Hall Meetings give the Groovy, Grails, and Micronaut team a chance to engage with you and empower you to contribute to the frameworks you love. Each Town Hall Meeting is led by a panel of 2GM users, developers, and advocates, and everyone is welcome and encouraged to participate.

We look forward to seeing you on September 24th, where we'll be sharing an update on our Productivity Tips 'n' Tricks guide, chatting about the latest technology releases, and more!

Reserve your seat

Grails Deep Dive Training Class Scheduled

Jen Wiese — Thu, 02 Sep 2021 00:00:00 GMT

If you've been wishing you could learn to maximize your productivity with the Grails framework directly from a member of the core Grails development team, this is your chance! A public offering of our popular Grails Deep Dive course starts next week.

This 4-day, 12-hour in-depth training workshop provides developers the knowledge and skills they need to quickly master the Grails framework. Become proficient with the technology in just a few days through live, instructor-led, hands-on training.

Learn more and enroll

Groovy 4 Webinar Coming Soon

Jen Wiese — Wed, 25 Aug 2021 00:00:00 GMT

Object Computing Groovy Project Lead, Paul King, presents a complimentary 60-minute webinar on September 16th in which he introduces the features and improvements you can expect in Apache Groovy 4.

Grails 5.0.0 RC1 Released

Puneet Behl — Wed, 11 Aug 2021 00:00:00 GMT

The Grails® Foundation is pleased to announce the first release candidate of Grails framework 5.0.0! With this release, we are one step closer to the Grails framework's next GA release!

Overview

Grails framework 5 represents a significant upgrade, with the Framework now rebased on top of an updated minimum set of dependencies including:

Spring 5.3.9
Spring Boot 2.5.3
Apache Groovy 3
Hibernate 5.5
Gradle 6.9

A major highlight of Grails framework 5 is support for Apache Groovy 3, which comes with the brand new Parrot parser and a bunch of new features and capabilities. The Parrot parser supports additional syntax and language features, such as lambda expressions, default methods with interfaces, and a lot more. See the release notes for Groovy 3.0 for details.

Grails framework 5 also upgrades to Spring 5.3.9 and Spring Boot 2.5.3, which have a minimum Gradle requirement of 6.8 or later and a default Apache Groovy version of 3. We strongly recommend that users check out the following Spring technologies release notes for more information:

This release also provides support for Java 15.

Many Grails plugins should work with Grails framework 5. For those in the Grails plugin community, now is the time to upgrade your plugins and verify they continue to work with Grails framework 5.

Important Changes

Dot-based(a.b.c) access to config is deprecated and will be removed in future.
The grails-publish-plugin has been removed.
The grails-gradle-plugin has been moved out of grails-core and may follow a separate versioning from grailsCore, so you should decouple the grailsVersion Gradle property from grailsGradlePluginVersion in existing applications.
grails.util.Metadata includes breaking changes as part of improvements.

Download

The easiest way to get started is to use SDKMAN! (The Software Development Kit Manager) to download Grails 5.0.0.RC1. Alternatively, you could download the Grails Binary directly from the Github Release page.

Conclusion

Thanks to all those who contributed to this release. Please follow us on Twitter @grailsframework for the most up-to-date information on the framework.

Calling All 2GM Users: Share Your Productivity Tips

Jen Wiese — Tue, 20 Jul 2021 00:00:00 GMT

We're all about sharing it back.

The Object Computing Groovy, Grails, and Micronaut team is collecting tips to compile into a resource that the global developer community can benefit from. By sharing your tips, you can help your peers build better solutions, making all of us stronger.

What’s your go-to productivity tool or technique?

No idea is too small! The little tips are often the things that add up to make the biggest difference. Bonus points if the trick isn't documented anywhere – you may be the first person to figure something out!

Highlights from your submissions will be shared with the 2GM community. This is a great chance to help your fellow developers improve their skills ... and who knows? Maybe you'll also win some cool swag!

Ready to participate?

Head over to this link and give us a peek inside your bag of tricks by sharing executable code, representative code snippets, or prose describing any practical tips you rely on to write better code faster.

Multiple submissions are welcome; we just ask that you have all your ideas submitted by August 31st.

We can’t wait to see all of the cool tips and tricks you've come up with!

Updated Grails Wrapper for Grails 3 and 4 projects

Jason Schindler — Thu, 10 Jun 2021 00:00:00 GMT

Recently, the Grails Framework Artifactory instance was updated. As a result, the Grails wrapper now fails under certain conditions because the URL it uses to retrieve information is no longer supported.

We are preparing a patch release of Grails framework 4 and Grails framework 3 to make new applications work with the change, but for existing Grails framework 3 and Grails framework 4 applications, the grailsw command will fail if the necessary assets haven't already been cached on the machine.

The error received is:

You must be connected to the internet the first time you use the Grails wrapper
org.xml.sax.SAXParseException; lineNumber: 6; columnNumber: 3; The element type "hr" must be terminated by the matching end-tag "".

Updating Existing Projects

To fix this, replace the grails-wrapper.jar file in the base of your existing project with one of the updated wrappers below:

Running the grailsw command from within the project should now work as expected.

Changing Repository URL

In addition to fixing the URL, we have also added the ability to change the base URL that the wrapper uses.

There are two possible mechanisms for doing this:

Setting an environment variable named GRAILS_CORE_ARTIFACTORY_BASE_URL
Setting the grails.core.artifactory.baseUrl system property

The default value is https://repo.grails.org/grails/core, and we do not expect that to change.

Wrapping Up

We apologize for any inconvenience you may have experienced by this recent change. We will post a more detailed post-mortem on these events in the next few days. Please continue to report any issues you encounter.

2GM Town Hall Meeting: 2021 Q2

Jen Wiese — Fri, 21 May 2021 00:00:00 GMT

Tags: #webinar #townhall

A big thanks to everyone who joined us for our Q2 2GM Town Hall Meeting! For those of you who missed the live event, the recording is embedded below.

At this quarter's meeting, we shared updates regarding the Grails and Micronaut roadmaps, discussed changes to the Micronaut Guides, talked about how to become a sponsor of the Grails and Micronaut Foundations, and encouraged qualified community members to apply to join the 2GM engineering team! You can find all of Object Computing's open positions here.

Also, special thanks to our fantastic panel of experts: Jeff Scott Brown, David Estes, Iván López, and Graeme Rocher.

Till next time!

— Jen Wiese

How to Publish a Grails Plugin to the Maven Central Repository

Puneet Behl — Wed, 07 Apr 2021 00:00:00 GMT

Tags: #bintray #plugins

Beginning May 1, 2021, you will no longer be able to publish your Grails plugins/artifacts to JFrog Bintray. We have already copied most of the Grails plugins from JFrog Bintray to the Grails Artifactory, which allows us to resolve those artifacts. Going forward, we recommend that you start publishing artifacts to Maven Central.

In this post, we outline how to publish Grails plugins to Maven Central. For detailed information, we also suggest checking Sonatype OSSRH Guide.

The Sonatype’s OSSRH service is the primary place to publish plugins to the Central repository. In order to use OSSRH, you need to take care of a few prerequisites and follow some basic steps.

Prerequisites

Choose your coordinates

When publishing Grails plugins to Bintray, it was possible to publish under the same groupId (org.grails.plugins).

To publish to Sonatype, the groupID needs to be changed.
1. If your plugins are hosted on GitHub, you could use "io.github.yourusername", "io.github.yourorganization", etc. For example: "io.github.puneetbehl", where "puneetbehl" is my GitHub username.
2. If you own or manage a domain then you could use groupId starting with the reverse domain name.
Please note that there is a Sonatype validation process to verify that you own the GitHub username or control the domain. See Individual Projects - Open Source Software Repository Hosting (OSSRH) for more information.
Sign up and provide project details

Once you identify a groupId, claim your namespace on the central repository.
1. Sign up on Sonatype JIRA.
2. Provide project details by creating a new project ticket.
  1. Create a new Issue in the "Community Support - Open Source Project Repository Hosting" project.
  2. The issue type should be "New Project".
  3. On the Project Details page, enter basic project details. See the screenshot below for an example: NOTE: Once the ticket is resolved, you should be good to deploy your artifacts.
Make sure your project meets the minimum requirements

When publishing to the central repository, your project must meet a basic set of metadata and content requirements. Even though metadata will be generated with Gradle plugins, it is useful to understand it.
1. Javadoc and Sources
  
  Verify that your plugin supplies javadoc and sources. For example, if your plugin name is myplugin then it should also package "myplugin-1.0.0-sources.jar" and "myplugin-1.0.0-javadoc.jar".
2. Sign Files with GnuPG/PGP
  
  All files must be signed with GnuPG/PGP, and an ".asc" file containing the signature must be included for each file. For example, when you deploy, the following files must be included:
  - myplugin-1.0.0.pom
  - myplugin-1.0.0.jar
  - myplugin-1.0.0-sources.jar
  - myplugin-1.0.0-javadoc.jar
  - myplugin-1.0.0.pom.asc
  - myplugin-1.0.0.jar.asc
  - myplugin-1.0.0-sources.jar.asc
  - myplugin-1.0.0-javadoc.jar.asc
3. Metadata
  
  Ensure that the POM file contains the following metadata:
  - Project coordinates - groupId, artifactId, version
  - Project name, description, and URL
  - Declare license
  - Developer information
  - SCM information
  You can refer to the Sonatype Requirements page for more information.
4. Install GnuPG, and Distribute Your Public Key
  
  One of the requirements for publishing to the central repository is to sign your artifacts using GnuPG. To install it, please read the instructions here.
  
  After generating the GnuPG key, distribute your public key to the key server so others can use it to verify your files. See Distributing Your Public Key Section.
  
  You may receive an error from Sonatype stating that the signature could not be verified. The error message will list the key servers that it is checking. You may need to distribute your key to another server (for example: http://keyserver.ubuntu.com:11371) in order for Sonatype to validate the artifacts.

Publishing

In order to deploy your plugin artifacts to OSSRH, you must meet the requirements for metadata in the POM and sign the artifacts. But first, let’s remove the previous Grails plugin, which was used to upload artifacts to JFrog Bintray.

The previous Grails plugin is configured with "grails-plugin-publish", which uses a Gradle Bintray plugin to upload artifacts.

Delete the following lines from your project build.gradle file to remove the plugin:

apply plugin:"org.grails.grails-plugin-publish"

grailsPublish {
   user = 'user'
   key = 'key'
   githubSlug = 'foo/bar'
   license {
       name = 'Apache-2.0'
   }
   title = "My Plugin"
   desc = "Full plugin description"
   developers = [johndoe:"John Doe"]
}

Generating Metadata

Use the Gradle maven-publish plugin to generate the necessary metadata, and deploy artifacts to the repository.

Apply the Maven Publish plugin
```
apply plugin: 'maven-publish'
```

Customize Metadata - The following sample shows how to customize the metadata for a Grails plugin:

group 'io.github.puneetbehl'
Version '1.0.0'

publishing {
   publications {
       maven(MavenPublication) {
           groupId = project.group
           artifactId = 'my-plugin'
           version = project.version

           from components.java
           artifact sourcesJar
           artifact javadocJar

           pom {
               name = 'My Grails Plugin'
               description = 'A concise description of my library'
               url = 'https://github.com/puneetbehl/myplugin'
               licenses {
                   license {
                       name = 'The Apache License, Version 2.0'
                       url = 'https://www.apache.org/licenses/LICENSE-2.0.txt'
                   }
               }
               developers {
                   developer {
                       id = 'puneetbehl'
                       name = 'Puneet Behl'
                       email = 'behlp@unityfoundation.io'
                   }
               }
               scm {
                   connection = 'scm:git:git://github.com/puneetbehl/myplugin.git'
                   developerConnection = 'scm:git:ssh://github.com:puneetbehl/myplugin.git'
                   url = 'https://github.com/puneetbehl/myplugin/tree/main'
               }
           }
       }
   }
}

Signing Artifacts

Use the Gradle Signing plugin to sign the artifacts, including metadata and pom.

Apply the Signing Plugin
```
apply plugin: 'signing'
```

Provide GnuPG key Information in your build.gradle file.

ext."signing.keyId" = project.hasProperty("signing.keyId") ? project.getProperty('signing.keyId') : System.getenv('SIGNING_KEY_ID')
ext."signing.password" = project.hasProperty("signing.password") ? project.getProperty('signing.password') : System.getenv('SIGNING_PASSPHRASE')
ext."signing.secretKeyRingFile" = project.hasProperty("signing.secretKeyRingFile") ? project.getProperty('signing.secretKeyRingFile') : (System.getenv('SIGNING_PASSPHRASE')?:"${System.properties['user.home']}${File.separator}.gnupg${File.separator}secring.gpg")

Get Signatory Credentials
1. Get the public key ID (The last 8 symbols using gpg -K command).
2. Export the keys with command gpg --keyring secring.gpg --export-secret-keys > ~/.gnupg/secring.gpg.
3. Know the Passphrase used to protect private keys.
Export the following environment variables
1. SIGNING_KEY_ID - The public key ID.
2. SIGNING_PASSPHRASE - The passphrase used while generating GnuPG key.
3. SECRING_FILE - The path to secring.gpg file.

Sign the artifacts and also prevent signing snapshots by adding required check as follows:

ext.isReleaseVersion = !version.endsWith("SNAPSHOT")

afterEvaluate {
   signing {
       required { isReleaseVersion && gradle.taskGraph.hasTask("publish") }
       sign publishing.publications.maven
   }
}

tasks.withType(Sign) {
   onlyIf { isReleaseVersion }
}

Configuring A Multi-Project Build

In case of multi-project builds, you need to configure plugins to generate metadata and signing for each of the sub-projects. The easiest way to achieve this is:
```
subprojects { project ->
    // your code here
}
```
Publish Your Artifacts to OSSRH, followed by release to Maven Central

The Gradle Nexus Publish Plugin is used to publish your artifacts to Sonatype and then to Maven Central in a fully automated way. Check the plugin README for more information.
1. Applying the plugin
```
buildscript {
   repositories {
       maven { url "https://repo.grails.org/grails/core" }
       maven { url "https://plugins.gradle.org/m2/" }
   }
   dependencies {
       classpath "org.grails:grails-gradle-plugin:$grailsVersion"
       classpath "com.bertramlabs.plugins:asset-pipeline-gradle:3.0.10"
       classpath "io.github.gradle-nexus:publish-plugin:1.0.0"
   }
}


apply plugin: 'maven-publish'
apply plugin: 'signing'
apply plugin: "io.github.gradle-nexus.publish-plugin"
```
2. To publish to Maven Central via Sonatype OSSRH, add the Sonatype repository as follows:
```
nexusPublishing {
   repositories {
       sonatype {
           def ossUser = System.getenv("SONATYPE_USERNAME") ?: project.hasProperty("sonatypeOssUsername") ? project.sonatypeOssUsername : ''
           def ossPass = System.getenv("SONATYPE_PASSWORD") ?: project.hasProperty("sonatypeOssPassword") ? project.sonatypeOssPassword : ''
           def ossStagingProfileId = System.getenv("SONATYPE_STAGING_PROFILE_ID") ?: project.hasProperty("sonatypeOssStagingProfileId") ? project.sonatypeOssStagingProfileId : ''
           nexusUrl = uri("https://s01.oss.sonatype.org/service/local/")
           snapshotRepositoryUrl = uri("https://s01.oss.sonatype.org/content/repositories/snapshots/")
           username = ossUser
           password = ossPass
           stagingProfileId = ossStagingProfileId
       }
   }
}
```
  Please note that in case of a multi project build, you must add the configuration from steps 1 and 2 under the root project.
3. Retrieve the Sonatype Staging Profile ID
  1. Log in to https://s01.oss.sonatype.org/ using your Sonatype credentials.
  2. Select "Staging Profiles" under the "Build Promotions" section in the left navigation panel.
  3. Select the Staging Profile with name as the groupId value.
  4. Copy the last part in your browser URL which is the Staging Profile ID. For example, when the browser URL is https://s01.oss.sonatype.org/#stagingProfiles;ce7c8eca12345 then profile id is "ce7c8eca12345" (the portion after semicolon).
4. Export the following environment variables:
  1. SONATYPE_USERNAME - Your sonatype username
  2. SONATYPE_PASSWORD - Your sonatype password
  3. SONATYPE_STAGING_PROFILE_ID - The Staging Profile ID copied in the previous step
5. Publish artifacts to the new staging repository and verify them manually.
```
./gradlew publishToSonatype closeSonatypeStagingRepository
```
6. After verifying, manually drop the staging repository.
  1. Log in to https://s01.oss.sonatype.org/
  2. Click on "Staging Repositories" which is under the Build Promotion section in the left navigation.
  3. Click the checkbox against the repository and select drop.
7. Publish artifacts to the new staging repository and verify them manually.
```
./gradlew publishToSonatype closeAndReleaseSonatypeStagingRepository
```

Automate Publishing Using GitHub Action

To automatically release using GitHub Workflow, add the following .github/workflows/release.yml workflow configuration file to your project.

When using this file, you must configure the following GitHub Secrets:

SONATYPE_USERNAME
SONATYPE_PASSWORD
SONATYPE_STAGING_PROFILE_ID
SIGNING_KEY
SIGNING_PASSPHRASE
SECRING_FILE - This is a BASE64 encoded value. Run the command gpg --keyring ~/.gnupg/pubring.kbx --export-secret-keys > ~/.gnupg/secring.gpg && base64 ~/.gnupg/secring.gpg | pbcopy to copy BASE64 encoded value to the clipboard.

To trigger a release, create a new release from the GitHub releases page. Here is a sample Grails Plugin that's configured to publish to Maven Central.

Update Information on Grails Plugin Portal

The Grails Plugin Portal uses the grails-plugins.json metadata file to display plugin information.

The metadata is hosted at https://github.com/apache/grails-plugins-metadata/blob/main/grails-plugins.json. When you publish a new plugin or release an existing plugin, you must send a pull request to this file to update the information on the portal.

When you release a new plugin, add the following information at the end of the JSON file:

{
    "bintrayPackage": {
        "name": "My Plugin",
        "repo": "plugins",
        "owner": "puneetbehl",
        "desc": "A concise description",
        "labels": [
                "grails3",
                "spring-boot",
                "test-label"
        ],
        "licenses": [
                "Apache-2.0"
        ],
        "issueTrackerUrl": "https://github.com/puneetbehl/myplugin/issues",
        "latestVersion": "1.1",
        "updated": "2021-03-25T04:00:40.855Z",
        "systemIds": [
                "io.github.puneetbehl:myplugin"
        ],
        "vcsUrl": "https://github.com/puneetbehl/myplugin"
    }
    "documentationUrl": "https://puneetbehl.github.io/myplugin/",
    "mavenMetadataUrl": "https://repo1.maven.org/maven2/com/github/puneetbehl/myplugin/maven-metadata.xml",
}

If you publish a new version to Maven Central, locate the entry in the JSON file and updatelatestVersion and mavenMetadataUrl. This will reflect the latest version in the plugin portal. In the future, we will use the mavenMetadataUrl field to automatically update the latest version.

Meet the Grails® Framework's New Mascot, Sir Gideon of Grails!

Jen Wiese — Mon, 22 Mar 2021 00:00:00 GMT

Tags: #mascot

In February 2021, we introduced the Grails framework's brand new mascot and reached out to our community to give the knight a name. The winner had a chance to win a one-of-a-kind Grails swag bag (and bragging rights, of course).

We were absolutely delighted to see the creativity, enthusiasm, and support the Grails community contributed to our quest. We received an amazing number of responses with some super imaginative suggestions.

So, the community has voted, and the Grails mascot has been named!

And the knight's new name is …

[Drumroll please …]

Gideon!

The name Gideon was overwhelmingly the top pick. Since multiple people suggested the name, we drew several winners from those entries to receive a swag bag. Please join me in congratulating winners: Joshua Freivald, Joe Little, and Benjamin Suffin! And if you were one of the many people who suggested we name the knight Gideon who didn't win a swag bag, please feel free to enjoy the bragging rights. Every time you see Sir Gideon out there, you'll know you were part of his "Hello World" development.

Huge thanks to everyone who took part in the Name the Knight contest. Even if your name wasn't chosen, your participation reminded us just how much we love and appreciate the Grails community.

Important Information Regarding Grails and Bintray

Jason Schindler — Fri, 12 Feb 2021 00:00:00 GMT

Tags: #bintray #plugins

As many of you know, last week JFrog announced that they are sunsetting JCenter and Bintray. On March 31st, JCenter will no longer accept new package submissions, but it will continue to serve artifacts until February 1st of 2022. On May 1, 2021, Bintray will be shut down. After May 1st, artifacts hosted by Bintray and the Bintray API will not be available.

This has a large impact on the Grails community, as we have been using Bintray for quite some time to host a number of our artifacts, as well as the community plugins under the org.grails.plugins group ID. Additionally, the Grails Plugins Portal utilizes the Bintray API to retrieve needed metadata to list and search plugins.

We have a plan, but it is going to require some lifting.

Moving Existing Artifacts Out of Bintray

Our primary concern is making sure existing artifacts can still be resolved after Bintray is shut down on May 1st. In order to achieve this, we will be moving existing artifacts including community plugins from Bintray to the Grails Artifactory instance. JFrog is not shutting down Artifactory and will continue to support our instance. This should allow existing artifacts to be served from Artifactory once Bintray is shut down, and current Grails applications should continue to have access to the artifacts and plugins that they need that are in our control.

Updating Grails Plugins Portal

As mentioned earlier, the Grails Plugins Portal is currently backed by the Bintray API. On May 1st, that API will be shut down with the rest of Bintray, so we need an alternative. We will create a public repository on GitHub that will host the metadata needed by the Grails Plugins Portal and can be managed by the community. Our intent is that this repository will periodically scan for updated release information and modify the metadata that the Grails Plugins Portal requires. This is a work in progress. We will announce more details about this process in the near future.

Publishing Community Plugins

Unfortunately, the loss of Bintray will require some extra effort from community plugin authors when you publish your next release.

First, you will no longer be able to publish to Bintray, and you will no longer be able to use the org.grails.plugins group. Community access to the org.grails.plugins group was a benefit of using Bintray that we cannot easily recreate. We could grant community plugin authors access to the Grails Artifactory instance, but doing so would create substantial user management overhead. It would also more tightly couple Grails to our JFrog Artifactory instance.

We feel a better solution is to maintain the plugin list publicly in a GitHub repository, and for plugin authors to publish their artifacts to another repository. Fortunately, community plugin authors have some options on where to publish their artifacts. We strongly suggest that folks publish to Maven Central. There is some extra overhead in publishing there, but we feel it is the safest bet for future availability of our artifacts.

The “grails-plugin-publish” Gradle plugin will no longer be able to publish Grails community plugins, as it supports publishing to Bintray with the gradle-bintray-plugin. To publish to Maven Central, we recommend that plugin authors switch to the Gradle Maven Publish plugin instead. We will be exercising this process ourselves in the coming days and will provide more details and guidance in the very near future.

Grails 5 Delay

Over the next few weeks, we will be focusing our efforts on this migration, and that is likely to cause a delay in the Grails 5 release. We want to wrap this up as quickly as possible so that we can get back to work on Grails 5!

Moving Forward

Thank you to all of you for your continued participation in the Grails community. We know that some of the changes resulting from this will be frustrating, and we ask for your patience as we work through this migration.

Webinar: 2GM TOWN HALL MEETING: 2021 Q1

Jen Wiese — Fri, 05 Feb 2021 00:00:00 GMT

Tags: #webinar #townhall

A big thanks to everyone who joined us for our first 2GM Town Hall of 2021! We had a great time and learned about several exciting goings on within the Groovy, Grails, and Micronaut communities. For those of you who missed the live event, the recording is embedded below.

I would like to take this opportunity to thank our awesome panel of experts:

James Kleeh, Micronaut Development Lead Puneet Behl, Grails Development Lead Paul King, Groovy Development Lead Plus, our guest panelist, Graeme Rocher, Architect at Oracle

Stay tuned for details about our next 2GM Town Hall meeting.

Continue reading on Object Computing, Inc. (OCI) website

Grails Framework Exciting Updates

Puneet Behl — Fri, 22 Jan 2021 00:00:00 GMT

Tags: #grails

We wish everyone a healthy and happy new year 2021 and thank all our users and contributors for your love and support of the Grails framework. We are excited to announce some of the upcoming changes around Grails releases, which will benefit the community and help with maintainability.

Adoption of Semantic Versioning

Starting with version 4.0.0, the Grails framework is following semantic versioning 2.0.0 to make the release process more predictable and simple. To understand what that means, please see the specification documentation

Announcing Grails 5!

To avoid violating semantic versioning, what had been planned to be Grails 4.1 will now be released as Grails 5. Once Grails 5 is released, we recommend users update their applications to benefit from the latest features and improvements. We believe that updating from Grails 4 to 5 should be a smooth experience as we have not made any major breaking changes in Grails 5 itself.

A major highlight of this release is the update to Apache Groovy 3, which includes support for Java 15 and significant other improvements around static compilation. We have also upgraded to the latest stable releases of some third-party libraries, including:

Apache Groovy 3, which offers several enhancements to the language, including GDK improvements, a new parrot parser – far more flexible than the previous versions – and a collection of other new features and capabilities.
SpringBoot 2.4: This release adds a significant number of new features and improvements, such as improvements to the config file processing, a new startup actuator endpoint to help identify beans that are taking longer than expected to start, and an update to Spring Framework 5.3. For more information, check out SpringBoot 2.4 release notes.
Gradle 6, which brings faster incremental Java and Groovy compilation, better version ordering, many bug fixes, and more. Refer to Gradle Release Notes for more information.

New Release Cadence

Going forward, the Grails framework will adhere to the following release cadence:

A patch release every 3 weeks, which will include only bug fixes and will not introduce new features or breaking changes
A minor release every 6 weeks, which will introduce new features/functionality in a backward compatible manner
A major release once every year, which may introduce breaking changes

This disciplined approach to releases will make the upgrade path for future minor and major releases easier.

Grails Framework EOL Schedule

In 2021, we will be scheduling “End Of Life” for Grails 2 and 3 as follows:

Grails 2 will be EOL after June 30th, 2021.
Grails 3 will be EOL after September 30th, 2021.

Going forward, with each major release, the previous major release will go into maintenance and support mode.

The Road Ahead

We are excited to continue to advance the Grails framework in the year 2021 with the support of the new Grails Foundation and great community. We will be focusing on improving the performance of the Grails application and user experience. In addition, we are planning a number of enhancements including:

Making GSP more modular and independent of the Grails framework
Transaction support in GORM for MongoDB
Native support for web-sockets
Continuously improving Grails documentation (especially around plugins, Micronaut configuration, HTTP Client, and other features)
Better integration with Micronaut, such as declarative HTTP Client
Better support for Kafka, including creating Kafka listeners through a plugin and more

Grails® Foundation Announced

Jen Wiese — Mon, 26 Oct 2020 00:00:00 GMT

Tags: #foundation

We're pleased to announce the formation of the new Grails^® Foundation, a not-for-profit company established to support and continue to advance the open source Grails® Framework.

The Grails Foundation oversees software roadmap and development, best practices and processes, repository control, documentation and support, and fundraising related to the open source framework.

2GM Town Hall Meeting: 2020 Q4

Jen Wiese — Fri, 16 Oct 2020 00:00:00 GMT

Tags: #townhall

A big thanks to everyone who joined us for our inaugural 2GM Town Hall webinar. We had a great time and learned about several exciting goings on within the Groovy, Grails^® framework, and Micronaut communities. For those of you who missed the live event, the recording is embedded below.

I would like to take this opportunity to thank our fantastic panel of experts:

James Kleeh, Micronaut Development Lead
Puneet Behl, Grails Development Lead
Jeff Scott Brown, Micronaut and Grails Practice Lead and Object Computing Partner
Plus, our guest panelist, David Estes

David is the co-founder and VP of Engineering at Morpheus Data and also the creator of the Grails Asset-Pipeline, which is broadly used by many developers in the Grails community. David has contributed to so many plugins over the years, he has lost count! Which is one of the many reasons we were thrilled to present him with the 2020 Grails Community Rock Star Award! Congratulations, David!

Stay tuned for details about our next 2GM Town Hall meeting, where Object Computing Groovy Development Lead, Paul King, will share the latest on Groovy 4.0, and we'll welcome a surprise special guest.

— Jen Wiese

2GM Product Evangelist

2GM Quarterly Town Hall Meetings

Jen Wiese — Thu, 01 Oct 2020 00:00:00 GMT

Tags: #townhall

At Object Computing, home to the Grails^® framework and Micronaut, our core values energize and guide us in all that we do. Those values are:

All of us is better than any one of us.
Innovate courageously.
Share it back.

As part of our commitment to empowering technologists – both within our organization and without – to find inspiration in these values, we invest our resources in open source projects. Through those projects, we have the opportunity to engage with the global open source community, including the Groovy, Grails framework, and Micronaut communities – communities that are supportive, enthusiastic, creative, and full of thought leaders.

2GM Town Hall Meetings provide the Groovy, Grails framework, and Micronaut communities a place to gather once per quarter to review the most up-to-date news and resources available, celebrate accomplishments, ask questions, and participate more fully in the 2GM ecosystems.

Each Town Hall Meeting is led by a panel of 2GM users, developers, and advocates. Everyone in the 2GM communities is welcome and encouraged to participate.

We look forward to hearing from you, learning from you, engaging with you, and empowering you to contribute to the community and the frameworks you love.

Grails® State of the Union

Puneet Behl — Thu, 10 Sep 2020 00:00:00 GMT

Tags: #micronaut #groovy3

As we approach the fourth quarter of 2020, I wanted to take a few minutes to update everyone in the community on the updates and enhancements coming to the Grails^® framework.

In the last few months, the 2GM (Groovy, Grails framework, and Micronaut) team has put a lot of work into the upcoming Grails 4.1 release. We’re excited to share that this release will include support for Apache Groovy 3! Groovy 3 offers a number of enhancements to the language including method references and a new, more flexible parser. Additionally, Grails 4.1 will support Micronaut 2.0, Gradle 6.5, and Spring 2.3. We’ve also added improvements to the Grails profiles to support the exclusion of transitive dependencies.

Apart from this, we've had some minor releases featuring bug fixes and improvements, which include (but are not limited to) the following:

Loading configurations from plugins
Significant improvements to the performance of compileGroovyPages and compileJsonView Gradle tasks
GORM for MongoDB to support MongoDB Sync driver 4.0.3
GORM for Neo4j to use the latest Neo4j driver version 4.0.1
Update to the latest Elasticsearch in the Grails Elasticsearch plugin
Injecting GORM Data Services

Developer Productivity FTW!

The Grails framework remains an excellent choice for rapidly building web applications. The framework utilizes the power of the Groovy language and offers lots of Groovy DSLs. If you prefer the dynamic nature of Groovy, the Grails framework is an excellent option for you.

Other benefits include the following:

The Grails framework gives you the power to use any Spring library; from Grails 3 forward, the framework is built on top of Spring Boot
In Grails 4, Micronaut is the parent application, which allows you to use many Micronaut features, including the Micronaut HTTP client, Kafka client, and others in your Grails apps. Due to Micronaut’s avoidance of reflection, you also benefit from a reduced memory footprint and faster start times!
The Grails framework provides a variety of compelling and powerful features, such as GSP, JSON Views, and more.
The Grails framework allows you to quickly and easily build an application because it takes advantage of the convention over configuration concept, wherein you:
- Do not need to use a lot of annotations, such as Controller, Service, etc.
- Do not need to specify every URL mapping
- Benefit from automatic code generation
- Can build REST APIs for domains

While the parent context in Grails 4 is Micronaut, it is worth noting that not all Micronaut features are supported in the Grails framework at this time. These include:

Anything that has to do with the server, such as tracing, Micronaut controllers, etc.
GraalVM native image support
Micronaut serverless, AWS Lambda, Functions, GRPC, etc.

As the Grails framework continues to evolve, so does the way that we are using Grails apps here at Object Computing. As I mentioned above, Grails 4 applications can now use many of Micronaut’s features, including the HTTP Client. If your application is using the GORM REST Client, we suggest migrating over to the Micronaut HTTP Client.

Also, because Grails 4 now uses Micronaut as the parent context, you can develop integrations for your applications using a Micronaut Configuration where you may have written a Grails plugin in the past. Doing so will enable your Grails application to make use of the new functionality and opens up the opportunity to use the configuration with other non-Grails applications that have been built on Micronaut!

Coming Soon

In addition to the improvements above, we are planning on a number of additional enhancements including:

Native support for web-sockets
Transaction support in GORM for MongoDB
Better support for Kafka, such as improvements in the CLI for creating Kafka listeners through the plugin
Ability to use GSP in Micronaut and Spring Boot applications by making GSP more modular and independent to the Grails framework
More Micronaut features, including reduced memory footprints and other benefits
Support for the latest Groovy and JDK.

Thank You

The continuing evolution and improvements to the Grails framework wouldn’t be possible without the work and support provided by the vibrant Grails community. If you are new to the Grails framework or are considering it for your next project, please stop by our Slack community and say "hello." We can’t wait to hear about the great applications you're building with Groovy and the Grails framework!

Webinar: Grails® 4 Upgrade

Sergio del Amo Caballero — Fri, 20 Dec 2019 00:00:00 GMT

Tags: #webinar

Join 2GM (Groovy, Grails^® framework, and Micronaut) team member, Sergio del Amo, for an in-depth demonstration of how to upgrade a Grails 3 application to Grails 4. Sergio also shows you how to benefit from the Micronaut integration available in the new iteration of the framework.

Outline

The following topics are covered in this webinar:

Grails 4 migration checklist
SpringBoot changes
Gradle changes
GORM changes
Plugin changes
Grails development hot reload
Micronaut + the Grails framework
Migration from Rest client builder to Micronaut HTTP client

Webinar: Groovy 3 and Beyond – An Insider's Guide

Paul King — Tue, 27 Aug 2019 00:00:00 GMT

Tags: #webinar #groovy

Overview

Apache Groovy 3 is approaching feature-complete status and is targeted for release over the coming months.

In this complimentary webinar, Object Computing Groovy Project Lead, Paul King, provides inside information on the release schedule and introduces the improvements and new features you can expect, including a new parser, improved JDK 9-14 support, and tooling enhancements.

Find out what the team has planned in the latest iteration of the language, and get a sneak peek at what's in the pipeline for Groovy 4!

Outline

The following topics are covered in this webinar.

Groovy roadmap for version 3
An overview of the new parser
- Lambda syntax and method/constructor references
- Improved looping and Java compatibility (try with resources)
- New operators (safe indexing, Elvis assignment, negated variants)
- The var reserved type
- Default methods in interfaces
Improved JDK 9+ support
- Split packaging and illegal access remediation
Tooling improvements
A peek at what's planned for Groovy 4 and beyond

Although everyone is welcome, this webinar is most useful to developers who use Java or Groovy (including any of the many projects in the Groovy ecosystem), as well as anyone with an interest in JVM languages. Previous exposure to Groovy is a plus, but no detailed knowledge is assumed.

Grails® 4 GA Released

Graeme Rocher — Thu, 11 Jul 2019 00:00:00 GMT

Tags: #release

After several release candidates and great feedback from the community, the Grails^® team at Object Computing, Inc. (OCI) is pleased to announce the GA availability of Grails 4.

Grails 4 represents a significant upgrade, with the framework now rebased on top of an updated minimum set of dependencies including:

Spring 5.1
Spring Boot 2.1
Java 8
Hibernate 5.4
Groovy 2.5
Gradle 5

In addition, Micronaut is now included as part of the Grails framework as the parent ApplicationContext, allowing any Micronaut feature, whether it be the declarative HTTP client or the Kafka client, to be used within a Grails 4 application. In fact the Micronaut HTTP client is now considered the supported HTTP client for use within Grails applications.

Startup time and memory consumption have also been optimized and improved significantly over previous releases, thanks to changes in both Spring Boot 2.1 and also the migration of some of the Grails framework's internal infrastructure wiring to Micronaut.

Many Grails plugins have been verified as working with Grails 4. For those within the Grails plugin community, now is the time to upgrade your plugins and verify they continue to work with Grails 4. As this is a new major version, API changes have been made, as well as changes within Spring Boot, Groovy, and Hibernate that may require changes to work with Grails 4. Please read the upgrade documentation for more information.

Thanks to all those who contributed to the release, and if you haven't already, do sign up for next week's webinar where we have more exciting announcements related to the Grails framework and Micronaut planned.

Webinar: Using Apache Groovy for Data Science

Paul King — Tue, 18 Jun 2019 00:00:00 GMT

Tags: #webinar #groovy

Apache Groovy is a multi-faceted, multi-paradigm programming language for the JVM that offers a wealth of features that make it ideal for transforming big data into usable solutions.

It has a dynamic nature like Python, which means that it is very powerful, easy to learn, and productive.
It has a static nature like Java and Kotlin, which makes it fast when needed.
And it has first-class functional support, meaning that it offers features and allows solutions similar to Scala.

In this complimentary webinar, Object Computing Groovy Practice Lead, Paul King, reviews the key benefits of using Groovy to develop data science solutions, including integration with various JDK libraries commonly used in data science solutions.

Possible Grails® MITM Vulnerability

Iván López — Thu, 30 May 2019 00:00:00 GMT

Introduction

In the Grails^® framework, we have been using Travis to automatically release new versions.

Some time ago, a user opened an issue detailing a possible MITM (Man in the Middle) attack because we were using a non-secured repository as part of the build process.

Our Analysis

The HTTP repository mentioned before was only used to resolve SDKMan notification service and not for any project dependencies. All project dependencies were resolved with HTTPS.

We have conducted an audit of the latest versions of the Grails 3.1.x, 3.2.x, 3.3.x, and 4.x lines, and we have verified that their contents have not been manipulated.

We undertook the same process as the Groovy team and diffed all jars and executable content. There were 6 differences in the generated byte code, which we isolated to an issue in the Groovy compiler, which was simply changing the order of the byte code output – not the byte code itself.

In addition, we have released Grails 3.3.10, which includes the applied patch, as well as a version of Groovy that also has the patch applied.

Assuring This Won't Happen Again

We have added a check that will make the build fail if any repository is not secure. You can get more information on this solution here.

Steps for Users

No action is necessary. The issue was specifically related to the build of the framework itself and not applications built with it. If there were an issue, it would have been introduced in the build of the Grails framework (not your Grails apps), and we have verified that Grails code itself was not compromised. Thus, users do not need to verify their own apps because they weren’t resolving dependencies over HTTP. However, in case of doubt, you can upgrade to Grails 3.3.10, which includes the applied patch.

Webinar: Single-Page Apps Simplified with the Grails® framework and Vue.js

Zachary Klein — Fri, 24 May 2019 00:00:00 GMT

Tags: #webinar

Vue.js is a modern, pragmatic JavaScript library designed for building user interfaces. Vue borrows good ideas from React and Angular, then adds a slew of features to enhance developer experience and productivity. Interest in Vue is through the roof, and for good reason.

The Grails^® framework includes a Vue profile for building applications with a Vue front-end. In addition, the Grails framework offers several features that make it an ideal back-end framework for single-page apps (SPAs), including JSON views and JWT authentication with the Spring Security REST plugin.

In this webinar, 2GM (Groovy, Grails framework, and Micronaut) team member, Zachary Klein, introduces the Vue.js library and walks you through a Grails project using Vue, REST, and JWT security. He completes the demonstration by demonstrating the steps necessary to build an executable JAR file with the Grails framework and Vue.

Outline

The following topics are covered in this webinar:

Introduction to Vue.js
Overview of the Vue profile for the Grails framework
Overview of Spring Security REST with JWT
Demonstration of how to implement JWT security with the Grails framework and Vue
Demonstration of a sample project using the Grails framework and Vue
Demonstration of an executable JAR build with Gradle

This is a great opportunity for Grails developers to add a new skill to their coding toolboxes! General web and JVM developers are also encouraged to discover what the Grails framework has to offer modern web development practices.

Webinar: Introducing Grails® 4: Upgrades and New Features

James Kleeh — Wed, 27 Mar 2019 00:00:00 GMT

Tags: #webinar

This webinar provides an introduction to the latest iteration of the Grails^® framework.

Overview

The first milestone of Grails 4 was released in February 2019, and further milestones and release candidates are forthcoming, pending community feedback.

This webinar, hosted by 2GM (Groovy, Grails framework, and Micronaut) team member James Kleeh, provides Grails users a summary of the new features they can expect in Grails 4 (including Micronaut integration!) and a good idea of what to expect regarding the upgrade process.

Outline

The following topics are covered in this webinar:

Differences between Grails 3 and Grails 4
Key upgrades and new features
Why Spring Loaded is out, and how this impacts your Grails applications
What Micronaut integration means for you
What to expect from the upgrade effort going forward

Grails® 4 Milestone 1 Released

Graeme Rocher — Tue, 19 Feb 2019 00:00:00 GMT

Tags: #release

The Grails^® team at Object Computing, Inc. (OCI) is pleased to announce the availability of the first milestone of Grails 4.

Grails 4 represents a significant upgrade with the framework now rebased on top of an updated minimum set of dependencies including:

Spring 5.1
Spring Boot 2.1
Java 8
Hibernate 5.4
Groovy 2.5

Many Grails plugins have been verified as working with Grails 4, and for those within the Grails plugin community, now is the time to upgrade your plugins and verify the plugins continue to work with Grails 4. As this is a new major version, API changes have been made, as well as changes within Spring Boot, Groovy, and Hibernate that may require changes to work with Grails 4. Please read the upgrade documentation for more information.

Thanks to all those who contributed to the release, and we look forward to your feedback and to seeing you at Devnexus 2019.

Quickcast #12: Building Grails® Applications with Gradle

Sergio del Amo Caballero — Wed, 30 Jan 2019 00:00:00 GMT

Tags: #quickcast

In this Grails^® Quickcast, 2GM (Groovy, Grails framework, and Micronaut) team member, Sergio del Amo, explores Grails integration with the Gradle build tool.

In this 25-minute tutorial, Sergio:

Explains the Gradle wrapper-related files
Explains how it's possible to delegate IDE build/run actions from IntelliJ IDEA to Gradle
Introduces common Gradle tasks for Grails developers, such as bootRun, test, integrationTest, and check or assemble
Demonstrates how to work with system properties and get a more verbose output from your Gradle test executions

Grails Quickcasts, brought to you through a partnership between Object Computing, Inc. (OCI) and DZone, provide bite-sized tutorials to help you maximize your productivity with the Framework.

SDKMAN! with Travis

Sergio del Amo Caballero — Mon, 07 Jan 2019 00:00:00 GMT

Tags: #deployment

The 2GM (Groovy, Grails^® framework, and Micronaut) team at Object Computing, Inc. (OCI) uses Travis CI and SDKMAN! daily.

Using SDKMAN! in Travis is possible and opens a lot of possibilities.

The following .travis.yml file will install SDKMAN! and create a Grails app using the latest version available.

install: true
jdk:
  - oraclejdk8
script:
  - curl -s get.sdkman.io | bash
  - source "$HOME/.sdkman/bin/sdkman-init.sh"
  - echo sdkman_auto_answer=true > ~/.sdkman/etc/config
  - source "/home/travis/.sdkman/bin/sdkman-init.sh"
  - sdk install grails

Webinar: Introduction to Grails® Multi-Tenancy

Sergio del Amo Caballero — Fri, 12 Oct 2018 00:00:00 GMT

Tags: #webinar

Overview

In this webinar, 2GM (Groovy, Grails^® framework, and Micronaut) team member, Sergio del Amo Caballero, demonstrates the multi-tenancy capabilities built into the Grails framework and GORM.

Multi-tenancy, as it relates to software development, is when a single instance of an application is used to service multiple clients (tenants) in such a way that each tenant's data is isolated from the other. Among other things, multi-tenancy enables you to build software as a service (SaaS) applications.

Grails developers interested in learning how to integrate multi-tenancy in their applications will get an introduction to the Grails framework's multi-tenancy capabilities and an in-depth demonstration of how to implement this powerful functionality.

Outline

The following topics are covered in this webinar:

Supported multi-tenancy modes (database, schema, discriminator)
The Grails framework's built-in tenant resolver
How to build your own tenant resolver
How to build a custom tenant resolver by logged-in user
How to configure datasources dynamically while using database multi-tenancy

This webinar is an excellent learning opportunity for Grails developers who wish to gain an understanding of Grails multi-tenancy capabilities and the possibilities therein.

Grails® Domain Read-Only Attribute

Nirav Assar — Tue, 02 Oct 2018 00:00:00 GMT

Tags: #gorm

Recently I encountered a situation with a client Grails^® application that required a read-only domain attribute. The application had a backend table where one column (call it A) was populated strictly by a batch database process. The table needed to be mapped to a Grails domain class. Certain columns (call them B through D) were to be updated from the UI. Attribute A should not be writable, but needed to be accessed for read-only operations.

The Problem

The catch here is when an update occurs on a mapped domain class, GORM with Hibernate issues an update on all columns, regardless of which columns have a value change. So even if attribute B is changed, an update will be issued on all columns A through D. If the database is configured with a specific column as read-only, you will get an error along the lines of: "failure to insert into a read-only column".

We propose two solutions:

Derived Properties
Hibernate's Dynamic update.

Example

Let's contrive a simple example with a domain class to understand the issue. Perhaps there is a Team with a name, coach, and nationalRank. name and coach are read-write attributes while nationalRank is the attribute which is read-only. It is updated strictly by a database batch process.

package grails.readonly.attribute

class Team {

    String name
    String coach
    Integer nationalRank

    static mapping = {
    }
}

Given a row already exists, we then issue an update with the statement:

team.name= "Raiders"
team.save(flush: true)

Hibernate will generate the log shown below. As you can see nationalRank is included in the statement, which will end up in an error due to the database constraint of read-only.

Hibernate: update team set version=?, national_rank=?, coach=?, name=? where id=? and version=?

Derived Properties

To prevent hibernate from including an attribute in the update statement, we can use the formula mapping for nationalRank. This means that GORM will allow us to access the property as though it were a normal column, but will ignore it for update operations (because formulas are, by definition, not updateable). In this case, the formula simply returns the value of the column, but the net effect gives us the desired behavior.

package grails.readonly.attribute

class Team {

    String name
    String coach
    Integer nationalRank

    static mapping = {
        nationalRank nullable: false, formula: 'NATIONAL_RANK'
    }
}

Now upon updates, the following hibernate log is generated (note the omission of nationalRank):

Hibernate: update team set version=?, coach=?, name=? where id=? and version=?

A derived property is one that takes its value from a SQL expression. E.g., tax formula: 'PRICE * TAX_RATE'. The formula expressed in the ORM DSL references to NATIONAL_RANK instead nationalRank. We are echoing a value which must be set elsewhere and cannot be inserted through GORM. So returning the column value directly achieves a read-only effect. DerivedProperties

DynamicUpdate

An alternate way of achieving the same result is to use hibernate's dynamicUpdate mapping. dynamicUpdate tells Hibernate whether to include unmodified properties in the SQL UPDATE statement. This excludes any attribute from the update statement which is not dirty.

package grails.readonly.attribute

class Team {

    String name
    String coach
    Integer nationalRank

    static mapping = {
        dynamicUpdate true
    }
}

Security Vulnerability in Asset-Pipeline and Jetty

Iván López — Sun, 23 Sep 2018 00:00:00 GMT

Tags: #plugins

Introduction

Asset-pipeline has been the default plugin for handling static assets in a Grails^® web application since Grails 2.4.0. A security vulnerability that involves asset-pipeline and Jetty has been identified.

Affected Versions

The vulnerability affects all asset-pipeline users that deploy Grails applications in Jetty, and it allows directory traversal and download any file knowing its specific directory.

Reproducing The Issue

Create a new grails application: grails create-app foo
In build.gradle change the spring-boot-starter-tomcat to spring-boot-starter-jetty
Build a war file: grails war
Deploy to Jetty
Send the following request to download Application.class wget localhost:8080/foo-0.1/assets/..%5c%5cfoo%5cApplication.class -O Application.class
It is also possible to download any any arbitrary file if the path is known. For example to download application.ymlexecute curl -v localhost:8080/foo-0.1/assets/..%5capplication.yml.

Fixing The Issue

The vulnerability has been addressed in recent versions of the asset-pipeline plugin:

2.14.1.1 for Grails 2.x
2.15.1 for Grails 3 and Java 7
3.0.6 for Grails 3 and Java 8

Quickcast #11: Grails® Profiling with YourKit

Nirav Assar — Wed, 22 Aug 2018 00:00:00 GMT

Tags: #quickcast #yourkit

In this Quickcast, 2GM (Groovy, Grails^® framework, and Micronaut) team member, Nirav Assar, demonstrates how to use YourKit to profile a Grails application and spot CPU problems and heap and garbage collection issues.

Grails Quickcasts, brought to you through a partnership between Object Computing, Inc. (OCI) and DZone, provide bite-sized tutorials to help you maximize your productivity with the Framework.

Quickcast #10: Debugging Grails® Apps

Iván López — Wed, 22 Aug 2018 00:00:00 GMT

Tags: #quickcast

In this 13-minute Quickcast, 2GM (Groovy, Grails^® framework, and Micronaut) team member, Iván López, demonstrates a variety of ways to debug Grails core code and the Grails CLI (command line interface). Developers may use these tips to fix issues or contribute enhancements to the core Grails framework.

Grails Quickcasts, brought to you through a partnership between Object Computing, Inc. (OCI) and DZone, provide bite-sized tutorials to help you maximize your productivity with the Framework.

Mock vs Stub vs Spy

Dean Del Ponte — Fri, 22 Jun 2018 00:00:00 GMT

Tags: #spock

Introduction

Spock provides three powerful yet distinct, tools that make working with collaborators easier:

Quite often, the code that is under test is required to interact with outside units of code known as collaborators. Unit tests are most often designed to focus on testing one class in isolation through the use of Mocks, Stubs or Spies. Tests are more robust and less prone to breakage should the collaborator code evolve.

These isolated tests are less brittle and less prone to breakage should the collaborators' internals be modified.

TLDR

Mocks

Use Mocks to:

verify the contract between the code under test and a collaborator
verify the the collaborator's method is called the correct number of times
verify the collaborator's method is called with the correct parameters

Stubs

Use Stubs to:

provide a predetermined response from a collaborator
take a predetermined action from a collaborator, like throwing an exception

Spies

Beware of Spies. As the Spock documentation states:

Think twice before using this feature. It might be better to change the design of the code under specification.

That being said, there are situations when we must work with legacy code. This legacy code may be difficult or impossible to test with Mocks or Stubs. In this case, Spies may be our only viable option.

It's better to have legacy code that is tested with a Spy then it is to have legacy code that is not tested at all.

Use Spies to:

test legacy code collaborators that are too difficult or impossible to test with a Mock or Spy
verify the collaborator's method is called the correct number of times
verify the collaborator's method is called with the correct parameters
provide a predetermined response from a collaborator
take a predetermined action from a collaborator, like throwing an exception

Mocks

The power of Mocks really shines when the goal of a unit test is to validate the contract between the code under test and a collaborator.

Let's take a look at the following example where we have a controller, FooController, which utilizes FooService as a collaborator and then test the functionality with a Mock.

FooController.groovy

package com.mycompany.myapp

import groovy.transform.CompileStatic

@CompileStatic
class FooController {
    FooService fooService

    def doSomething() {
        render fooService.doSomething("Sally")
    }
}

FooService.groovy

package com.mycompany.myapp

import groovy.transform.CompileStatic

@CompileStatic
class FooService {

    String doSomething(String name) {
        "Hi ${name}, FooService did something"
    }
}

In this scenario, we want to write a test that will validate:

the contract between FooController and FooService
FooService.doSomething(name) is called the correct number of times
FooService.doSomething(name) is passed the correct parameter

Here's the test:

MockSpec.groovy

package com.mycompany.myapp

import grails.testing.web.controllers.ControllerUnitTest
import spock.lang.Specification

class MockSpec extends Specification implements ControllerUnitTest {

    void "Mock FooService"() {
        given: "the collaborating service is mocked"
        def fooService = Mock(FooService)

        and: "the mocked service is set on the controller"
        controller.fooService = fooService

        when: "the controller action is called"
        controller.doSomething()

        then: "the Mock can be used to validate cardinality and parameters"
        1 * fooService.doSomething("Sally")

        and: "the mocked service returns the default 'zero value' of 'null'"
        response.text == null.toString()
    }
}

The above test mocks FooService by doing the following:

def fooService = Mock(FooService)

The test also verifies that FooService.doSomething(name) is called just once and the parameter passed to it is equal to a String value of "Sally".

1 * fooService.doSomething("Sally")

The above snippets of code accomplish four important tasks:

Creates a Mock for FooService
Ensures the FooService.doSomething(String name) method is called only once and the parameter name is equal to the String "Sally"
Isolates the code under test by mocking the implementation of the collaborator

Stubs

Does the code under test use a collaborator? Is the goal to ensure the code under test behaves properly when interacting with a collaborator? Does the collaborator act as input to the code under test?

If the behavior of the code under test will change based upon the behavior of the collaborator, then what you need to use is a Stub.

Let's take a look at the following example where we have a controller, FooController, which utilizes FooService as a collaborator and then test the functionality with a Stub.

FooController.groovy

package com.mycompany.myapp

import groovy.transform.CompileStatic

@CompileStatic
class FooController {
    FooService fooService

    def doSomething() {
        render fooService.doSomething("Sally")
    }
}

FooService.groovy

package com.mycompany.myapp

import groovy.transform.CompileStatic

@CompileStatic
class FooService {

    String doSomething(String name) {
        "Hi ${name}, FooService did something"
    }
}

Here's the test:

StubSpec.groovy

package com.mycompany.myapp

import grails.testing.web.controllers.ControllerUnitTest
import spock.lang.Specification

class StubSpec extends Specification implements ControllerUnitTest {

    void "Stub FooService"() {
        given: "the collaborating service is stubbed"
        def fooService = Stub(FooService) {
            doSomething(_) >> "Stub did something"
        }

        and: "the stubbed service is set on the controller"
        controller.fooService = fooService

        when: "the controller action is called"
        controller.doSomething()

        then: "the stubbed service returns the stubbed text"
        // 1 * fooService.doSomething() cardinality not supported by Stub
        response.text == "Stub did something"
    }
}

The above test stubs FooService by doing the following:

def fooService = Stub(FooService) {
    doSomething(_) >> "Stub did something"
}

The above code accomplishes four important tasks:

Creates a Stub for FooService
Ensures the FooService.doSomething(String name) method will return the String "Stub did something" independently of the name parameter value. Hence the use of _.
Isolates the code under test by mocking the implementation of the collaborator

Spies

Please don't read this section.

Look away.

Please skip ahead to the next section.

Still reading this? Well, okay, let's talk about Spies.

Do not use Spies. As the Spock documentation states:

Think twice before using this feature. It might be better to change the design of the code under specification.

That being said, there are situations when we must work with legacy code. The legacy code may be difficult to test with Mocks or Stubs. In this case, Spies may the only viable option.

Spies are different than Mocks or Stubs because they do not act as a test duplicate in the same sense.

When a class is Mocked or Stubbed, a test double is created and the original code that exists within the Mocked or Stubbed object is not executed.

Spies, on the other hand, will execute the original code from which the Spy was created, but a Spy will also allow you to modify what the Spy returns and verify cardinality much like Mocks and Stubs.

Let's take a look at the following example where we have a controller, FooController, which utilizes FooService as a collaborator and then test the functionality with a Spy.

FooController.groovy

package com.mycompany.myapp

import groovy.transform.CompileStatic

@CompileStatic
class FooController {
    FooService fooService

    def doSomething() {
        render fooService.doSomething("Sally")
    }
}

FooService.groovy

package com.mycompany.myapp

import groovy.transform.CompileStatic

@CompileStatic
class FooService {

    String doSomething(String name) {
        "Hi ${name}, FooService did something"
    }
}

Here's the test:

SpySpec.groovy

package com.mycompany.myapp

import grails.testing.web.controllers.ControllerUnitTest
import spock.lang.Specification

class SpySpec extends Specification implements ControllerUnitTest {

    void "Spy FooService"() { 
        given: "the collaborating service is a Spy"
        def fooService = Spy(FooService)

        and: "the Spy service is set on the controller"
        controller.fooService = fooService

        when: "the controller action is called"
        controller.doSomething()

        then: "the Spy can be used to validate cardinality"
        1 * fooService.doSomething("Sally") >> "A Spy can modify implementation"

        and: 'A spy can modify implementation'
        response.text == "A Spy can modify implementation"
    }
}

The above test creates a Spy on FooService by doing the following:

def fooService = Spy(FooService)
{% endhighlight %} 

The following code demonstrates how the Spy allows us to verify `FooService.doSomething(name)` is called just once and the parameter passed to it is equal to a String value of "Sally":
Moreover, it changes the method implementation to return a different String.

{% highlight groovy %}
1 * fooService.doSomething("Sally") >> "A Spy can modify implementation"

The following code demonstrates how the Spy allows us to verify FooService.doSomething(name) is called just once and the parameter passed to it is equal to a String value of "Sally": Moreover, it changes the method implementation to return a different String.

1 * fooService.doSomething("Sally") >> "A Spy can modify implementation"

The above code accomplishes four important tasks:

Creates a Spy for FooService
Verifies interaction with the collaborator.
Verifies how the application behaves when a collaborator responds in a certain way.

FAQ

Q: Should I use a Mock, a Stub, or a Spy?

A: This is a question faced by many a developer. The following FAQ may help if you are ever unsure as to which mocking option to use.

Q: Is the goal of the test to verify the contract between the code under test and a collaborator?
A: If you answered yes, use Mock

Q: Is the goal of the test to ensure the code under test behaves properly when interacting with a collaborator?
A: If you answered yes, use Stub

Q: Does the collaborator act as input to the code that is under test?
A: If you answered yes, use Stub

Q: Are you working with legacy code that is extremely difficult to test and you've exhausted all other options?
A: Try using a Spy

Sample Code

The sample code referenced in this post may be found at https://github.com/ddelponte/mock-stub-spy

Useful Links

Webinar: I've Seen Grails® Code You Wouldn't Believe

Iván López — Fri, 15 Jun 2018 00:00:00 GMT

Tags: #webinar

Overview

"I’ve seen Grails^® code you wouldn’t believe …

… or how to properly write maintainable Grails applications"

Over the years, Iván López has built a lot of different Grails applications, and he's learned from his mistakes. As an experienced Grails developer, Iván now possesses a vast amount of knowledge about how to avoid problems and pitfalls in future projects.

For over a year, Iván has been sharing his hard-won expertise with others, so they can benefit from his experience and write more maintainable code that's easy to read and modify.

In this 1-hour webinar, Iván walks you through code examples and demonstrates how to adapt them to best practices. You'll also see code examples that you should never, ever write, along with alternative solutions that will significantly improve your applications.

Iván says, "I promise no developers were harmed in the making of this talk."

Outline

The following topics are covered in this webinar:

Best practices for writing maintainable and testable Grails applications
How to detect bad code and tips for turning it into good code
Strategies for avoiding common pitfalls when writing Grails applications

This webinar is an excellent learning opportunity for Grails developers who have had problems adding new features or maintaining their Grails applications and would like to improve their speed, efficiency, and debugging skills.

Q&A Follow-Up

We had a lot of great questions at the end of this webinar. Here are Iván's responses to the questions we didn't have time to answer.

Q: Can you just define as many UrlMapping files as you wish in your webapp's grails-app/conf, as long as they have different names but end with UrlMapping.groovy?

A: Yes. Take a look at this commit in a sample project I've created for an example.

Q: Any best practices regarding withSession / withNewSession?

A: My best advice is to try not to use them. In most cases, you can create regular services and annotate them with @Transactional. In the other few places in which you need them, I almost always use withNewSession because there is no session available. In any case I try to avoid this as much as I can.

Q: Is it recommended to write business logic always in service layer?

A: Yes it is. Think about this. Imagine that you're creating a regular Grails application that renders GSPs pages, and also you want to create some RESTful or SOAP endpoints. If you write all your business logic in services, the only thing you need to do is call those services from the different endpoints: "regular" controllers, RESTful controllers, and SOAP endpoints.

In these 3 controllers you're dealing with a different transport/communication layer and returning the same thing, but in a different format: HTTP to render HTML, HTTP to return JSON, and HTTP to return SOAP. Once you validate the parameters in these layers (and you can also share the validation logic using command objects), the only thing you need to do is call the same service with the parameters needed.

What I always do when developing new features in a Grails application is start with the services. I don't think about controllers, just services. This way, I can think in terms of my business logic: "I need to receive these parameters, and I need to return this other thing."

Then I use TDD to develop the service, so I make sure that everything works.

After that, I go to the controllers layer, write command objects (with tests), and then write the controllers that call the services I finished in the previous step. As I already developed (and tested) my business logic when I created the services, I know that everything will work, and I just need to pass the appropriate parameters to the services.

Finally, when everything is done, I start up the application to make sure that everything works as expected (and it should because I have tests for everything).

Q: I’ve noticed a lot of auto-generated code when I’m single stepping through code (e.g., transactional wrappers). Any advice on best practice for avoiding this kind of overhead?

A: Most of that code is because of the Spring Framework. Since Grails 3, we rely a lot on AST transformations and traits to generate code during compilation to avoid that overhead.

For example, the Grails @Transactional annotation is applied at compile time vs. Spring @Transactional that relies on runtime proxies. The "problem" is that both Spring and Hibernate use runtime proxies and runtime reflection, so you can't get rid of all those wrappers.

If you want to avoid runtime proxies, I would suggest you take a look at Micronaut. :)

Grails® Mock Logging

Nirav Assar — Thu, 24 May 2018 00:00:00 GMT

In Grails^® 3 applications, logging is handled by the Logback logging framework. Grails artifacts are configured with logging out of the box. The developer simply invokes log.info("log whatever") and it works. But how do we create unit tests that assert that logs occur with the appropriate level?

This blog will highlight some mock logging techniques and when to use them.

Default Grails Logging in Unit Tests

First let's get the obvious out of the way for clarity. If you are not concerned about testing how logs operate in your application, there is no reason to worry about mocking loggers in Grails apps.

Since the logger is already present in Grails controllers, services, and domain objects there is no need to mock the logger when running unit tests. When a unit test is run with Grails Testing Support, the logger will execute just as in does in production mode. In this scenario, we can say the logger as already "mocked" for the purpose of focusing on the Class Under Test. This is distinct from the scenario of actually verifying logging occurs, which we will dive into next.

Verify Logging with Tests

What if we want to assert that a certain log occurs with a particular log level? For example, let's say we want to test that that the method below prints friendly advice based on the age parameter.

package mock.logging

class AgeService {

    void offerAgeAdvice(int age) {

        if (age < 0) {
            log.error ("You cannot be $age years old!")
        } else if (age in 0..<30) {
            log.info ("You are a young and vibrant :) Age $age")
            log.info ("Live life to the fullest")
        } else if (30 <= age) {
            log.warn ("It's all downhill from here, sorry. Age $age")
        }

    }
}

In this scenario we need to mock the logger and capture the message passed in. Then we can assert that the message is correct and also assert the appropriate log level was used in each scenario. Conceptually, this is pretty easy. But in practice not so much.

Why Not Use Spock?

One would think that we should simply mock out the logger with def mockLogger = Mock(Logger), then set the service in the unit test with service.log = mockLogger. We could proceed to check the arguments passed in and also the number of times service.log is called with spock programming. However, in Grails apps we run into a few basic problems while trying to mock with native spock or even Groovy MockFor.

Logback is the default framework and the Logger is final. We cannot mock a final class. Furthermore, the injected logproperty in Grails artifacts is a read-only property and cannot be set. These two fundamental problems prohibit spock mocks from being effective in most mock logging situations in Grails apps.

Use Mockito to Verify Log Events

The Mockito Library can be used to verify logs take place. With Mockito, we can create a mock Appender class, attach it to the logger, and then use an ArgumentCaptor to capture the invocations sent to the logger.

build.gradle

dependencies { 
    ...
    testCompile "org.mockito:mockito-core:2.+"
}

Spock test with Mockito

    void "verify logging with mockito appender"() {
        when: "we attach a mocked appender to the logger"
        Appender mockedAppender = Mockito.mock(Appender)
        Logger logger = LoggerFactory.getLogger("mock.logging.AgeService")
        logger.addAppender(mockedAppender)

        service.offerAgeAdvice(22)

        ArgumentCaptor argumentCaptor = ArgumentCaptor.forClass(Appender)
        Mockito.verify(mockedAppender,
                       Mockito.times(2)).doAppend(argumentCaptor.capture())
        logger.detachAppender(mockedAppender)

        then: "we capture the arguments and verify log statements occurred"
        argumentCaptor.getAllValues().size() == 2
        List loggingEvents = argumentCaptor.getAllValues()
        loggingEvents[0].getMessage() == "You are a young and vibrant :) Age 22"
        loggingEvents[0].getLevel() == Level.INFO
        loggingEvents[1].getMessage() == "Live life to the fullest"
        loggingEvents[1].getLevel() == Level.INFO
    }

Use Slf4j Test to Verify Log Events

Slf4j Test is a test implementation of Slf4j that stores log messages in memory and provides messages for retrieving them. This works nicely to substitute for the real implementation in the test environment of Grails apps.

In build.gradle, we first need to depend on the jar, and then exclude the real implementation from the test environment. It is quite simple to check the logging events.

build.gradle

dependencies { 
    ...
    testCompile 'uk.org.lidalia:slf4j-test:1.1.0'
}

configurations {
    testCompile.exclude group: 'ch.qos.logback', module: 'logback-classic'
}

Spock test with Slf4j Test

    void "verify logging with slf4j-test"() {
        when:
        TestLogger logger = TestLoggerFactory.getTestLogger("logging.AgeService")

        service.offerAgeAdvice(-1)

        ImmutableList loggingEvents = logger.getLoggingEvents()

        then:
        loggingEvents.size() == 1
        loggingEvents[0].message == "You cannot be -1 years old!"
        loggingEvents[0].level == uk.org.lidalia.slf4jext.Level.ERROR
    }

Use Spock Mocks With a Declared Logger

Spock mocks can be used on one particular case: with your own declared logger variable. If defined as non-final, you can use spock mocks to verify log calls. This approach is straightforward, but has the drawback that each class will have repeated code and does not rely on Grails conventions.

For example, use a LoggerFactory to define a logger in a class.

package mock.logging

import org.slf4j.Logger
import org.slf4j.LoggerFactory

/**
 * Non grails groovy class with a declared Slf4j logging object
 */
class DeclaredSlf4jService {

    private static Logger log = LoggerFactory.getLogger(DeclaredSlf4jService)

    void logSomething() {
        println "*********** log in the class ******" + log.dump()
        log.info("Live life to the fullest")
    }

Then a spock Specification with Mock() follows the normal spock conventions to verify invocations and parameters.

package mock.logging

import org.slf4j.Logger
import spock.lang.Specification

class DeclaredSlf4jServiceSpec extends Specification {

    DeclaredSlf4jService declaredSlf4jService = new DeclaredSlf4jService()
    def mockLogger = Mock(Logger)

    def setup() {
        declaredSlf4jService.log = mockLogger
    }

    def cleanup() {
    }

    void "test mock with spock on declared logger"() {
        when:
        declaredSlf4jService.logSomething()

        then:
        1 * mockLogger.info("Live life to the fullest")
    }
}

Sample Code

Sample code of Grails mocking logging can be found here. I hope these examples can help you decide on the best approach for your project.

Webinar: Groovy 2.5+ Roadmap with Paul King

Paul King — Fri, 18 May 2018 00:00:00 GMT

Tags: #webinar #groovy

In this webinar, Paul King introduces you to the latest features in Groovy 2.5 and offers a peek at what's planned for Groovy 3.0, including new AST transforms, new macro features, the new Parrot parser, and myriad other miscellaneous features.

Outline

The following topics are covered in this webinar.

AST Macros – write AST transformations and code generation or matching code in a Groovy friendly syntax
AST Transformations – new transforms and improvements including revamped versions of @Canonical and @Immutable
New DGM capabilities and library improvements – tap command, miscellaneous improvements
Improved tool support, including groovysh and Groovy console
Improvements throughout the libraries – JSON improvements, CliBuilder with annotations
The Parrot Parser – Java syntax alignment, new features, advanced capabilities
JDK9: support, limitations and on-going work

Webinar: Database Migration with Grails® 3

Nirav Assar — Fri, 06 Apr 2018 00:00:00 GMT

Tags: #webinar

Overview

Database migrations are an important facet of web development. Preserving existing data while seamlessly adding new functionality and tables is critical when making incremental database changes to production applications.

Without a tool to manage database migrations, developers end up cobbling together solutions using manual SQL, error-prone communication processes, and costly risk management strategies.

In this webinar, 2GM (Groovy, Grails^® framework, and Micronaut) team member, Nirav Assar, demonstrates how to apply the Grails Database Migration plugin in development and production.

Outline

The following topics are covered in this webinar:

Fundamental database management concepts
Overview of database migration tools
Demonstration of the Grails Database Migration plugin
Live coding examples representing real-world use cases
Advanced scenarios and best practices

GORM Logical Delete Plugin

Introducing the Grails® 3 GORM Logical Delete Plugin

Nirav Assar — Thu, 05 Apr 2018 00:00:00 GMT

Tags: #gorm #plugins

Recently our development team came upon the need to develop a Grails^® 3 plugin that implements logical delete for entities.

A "logical" delete (sometimes referred to as a "soft" delete) is a delete that doesn’t actually delete the relevant data but instead marks the data as deleted. Marking the data as deleted has the benefit of excluding the data from queries by default, while still maintaining the ability to retrieve the data when/if necessary. Essentially the plugin offers a mechanism to "hide" domain objects from retrieval. This is useful for retaining data without having it clutter the current set of active data.

Logical Delete functionality is available in a few Grails 2 plugins. However these implementations rely on filters, ASTs, and runtime metaClass enhancements. We decided to create another implementation of the logical delete using some of latest Grails 3 features such as Traits and Listeners.

This blog will highlight how to use the plugin and also give some insight into the techniques used under the covers.

Summary

Logical delete of an entity has a few relevant use cases in enterprise applications. Companies may want to "delete" data from their everyday usage, but still keep it for later retrieval. Auditing requirements for financial institutions may require the data to be sustained for up to seven years.

From a technical perspective, if a domain model has several complex associations that make a chain of domain objects, hard deletion may cause slow cascading affects or be blocked by referential integrity. In these situations, a logical delete alleviates these concerns.

Installation

To add the GORM Logical Delete plugin to an application, add the following dependency to the dependencies block of your build.gradle:

compile "org.grails.plugins:gorm-logical-delete:2.0.0.M2"

Enable Domain Entity with Logical Delete

Any domain entity can be implemented with the LogicalDelete trait. The trait adds a boolean persistent property named deleted to the domain class. The property is used to "hide" entities from queries if it is set to true. Note the mapping columns can customize the property to a database column name.

import gorm.logical.delete.LogicalDelete

class Person implements LogicalDelete {
    String userName

    static mapping = {
        // the deleted property may be configured
        // like any other persistent property...
        deleted column:"delFlag"
    }
}

In order to delete a domain object enabled with logical delete, simply use the same GORM interface as usual.

Person p = new Person(userName: "Nirav").save()
p.delete()

If you would like to physically delete the record from persistence, use the attribute hard: true:

p.delete(hard: true)

Undelete functionality is quite handy if you want to reverse the property to false.

Person.withDeleted {
    Person p = Person.get(id)
    p?.unDelete()
}

Querying Objects

When an object is enabled with logical delete, queries associated with the domain object will hide those marked with deleted = true.

Dynamic Finders, Criteria Query, Detached Criteria Query, and the GormEntity methods like get, load, proxy, and read are all supported.

See the Query documentation for a list of examples.

Note Hibernate Criteria and HQL queries are NOT supported by this plugin as they are ORM implementation specific.

Behind The Scenes

It's beneficial to understand how the plugin is implemented under the covers. We have tried to use the most efficient techniques with Groovy and the Grails framework, which reduces some of the noise and clutter found in previous plugin implementations.

In concept, what is occurring is that any domain object can be given a logical delete capability with the attribute deleted. When the entity is logically deleted, it is set to true. It is not physically deleted from persistence. During query time, a query event is intercepted by a listener and the query is altered to only include deleted = false items from the result set. This gives the illusion that the items are not present, but in reality they are just hidden by the query.

LogicalDelete

The LogicalDelete trait makes available a deleted attribute. As stated earlier, an entity can implement this.

The LogicalDelete trait has overridden static methods which take into account the deleted property in an altered query. This allows the client to use the GormEntity methods to essentially hide those items.

PreQueryListener

The PreQueryListener implements ApplicationListener and when the event fires, it will add a deleted equals false to the query.

The ThreadLocal variable IGNORE_DELETED_FILTER should also be noted. When set to true, then all entities that exist in the database are included in the query. In other words, it bypasses the logical delete flag all together. In LogicalDelete, note how this ThreadLocal variable is used in the withDeleted method. The method is passed in a closure (which is a query) and the variable is set to true, which bypasses the delete flag.

WithDeletedTransformation essentially achieves the same goal, but is intended as an implementation for an annotation.

The spock tests contained in the plugin are a good resource to reference examples and usages of the plugin API.

Take a look and we hope the plugin is useful for your needs.

Webinar: Build a Better API with GORM & GraphQL

James Kleeh — Fri, 09 Mar 2018 00:00:00 GMT

Tags: #webinar #gorm #graphql

Overview

GraphQL is an exceptional technology that allows APIs to be more efficient and expressive. GORM is the object relational mapper used by Grails^® apps that enables developers to interact with both relational and document databases through the declaration of simple Groovy classes.

In this 55-minute webinar, 2GM (Groovy, Grails framework, and Micronaut) team member, James Kleeh, discusses in depth a new GORM extension and Grails plugin that combine these two great technologies and increase developer productivity.

Outline

The following topics are covered in this webinar.

GORM Introduction
GraphQL Introduction
Comparison of GraphQL vs REST
GORM-GraphQL Features
GORM-GraphQL Customizations
GORM-GraphQL Testing

This webinar is an excellent learning opportunity for developers who wish to improve the efficiency and expressiveness of their APIs.

Webinar: Browser Automation Testing with Geb & the Grails® Framework

Sergio del Amo Caballero & Marcin Erdmann — Tue, 06 Mar 2018 00:00:00 GMT

Tags: #webinar #geb

Geb brings together the power of WebDriver, the elegance of jQuery content selection, the robustness of page-object modeling, and the expressiveness of the Groovy language. Together with Spock, Geb integrates into Grails^® apps to ease the creation of functionals/acceptance tests.

In this webinar, Geb Lead, Marcin Erdmann, and Grails team member, Sergio del Amo Caballero, discuss how Geb integrates seamlessly into the Grails workflow and how this combination leads to robust and well-tested applications.

Grails® Development with Groovy Eclipse

Sergio Del Amo Caballero — Fri, 02 Mar 2018 00:00:00 GMT

Tags: #groovy #eclipse #gradle

In this blog post, we show the steps necessary to set up Eclipse IDE to develop Grails^® 3 applications.

Groovy Eclipse

First step is to install Groovy Eclipse. Check the installation instructions.

Once, you have set up Groovy Eclipse, set up the compiler to use Groovy 2.4.13; the version used by the latest stable release of Grails 3.3.2.

Eclipse Spock Plugin

Install Eclipse Spock Plugin

Buildship Gradle Plugin

Install Buildship Gradle plugin.

We are going to rely on Gradle tasks to drive our Grails development in Eclipse. Thus, you may want to enable Gradle views.

Gradle Tips

When you work often with Gradle it becomes useful to get a verbose output while you run your tests:

tasks.withType(Test) {
      beforeTest { descriptor -> logger.quiet " -- $descriptor" }
     testLogging {
         events "passed", "skipped", "failed"
         exceptionFormat 'full'
     }
 }

Common Grails Gradle Tasks

Run your app

./gradlew bootRun

Run unit tests

./gradlew test

Run integration/functional tests

./gradlew integrationTest

Run ALL tests unit/integration/functional

./gradlew check

Clean

./gradlew clean

Build your artifacts

./gradlew assemble

Dependency report

./gradlew dependencies

Webinar: Developing React Apps with Grails® 3

Zachary Klein — Fri, 09 Feb 2018 00:00:00 GMT

Tags: #webinar #react #javascript

Overview

React is the JavaScript view library from our friends at Facebook. Rather than providing a "full-stack framework" for the front end, React focuses entirely on being the 'V' in MVC.

In this 60-minute webinar, 2GM (Groovy, Grails^® framework, and Micronaut) team member, Zachary Klein, demonstrates how to leverage React in your projects. You'll learn several ways to use these two frameworks together and get an introduction to the React profile for Grails apps.

Outline

The following topics are covered in this webinar:

Overview of React and build tooling
3 Approaches to building Grails projects with React
The React profile
Spring Security REST
Unified deployment

This webinar is a useful tutorial for Grails developers interested in adding React or another front-end framework/library to their projects. Front-end developers are also encouraged to discover what the Grails framework has to offer in a modern web development workflow.