feat(arch): Wire generated projects as a Spring Boot application

Generated projects now assemble into a Spring context on Spring Boot 4.0.6:

- parent/pom.xml inherits spring-boot-starter-parent (4.0.6) via <parent> with an
  empty <relativePath/>, providing Spring dependency management and plugin defaults
- every app-composed module carries a @configuration class in its .config
  subpackage and declares spring-context
- app holds the Spring Boot Application (@SpringBootApplication,
  @EnableTransactionManagement) and AppServletInitializer (WAR) classes in
  {package}.app.config; Application @imports every module's @configuration
- app adds spring-boot-starter-web and spring-boot-starter-data-jpa

The integration tests assert this wiring and confirm each generated project still
builds (mvn verify) with the Spring stack on the classpath.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FTaQTM9wYTXLvvgCXSwhRm

Author: jeffjensen

src/main/resources/META-INF/archetype-post-generate.groovy

@@ -75,16 +75,20 @@ def failsafeSection = """\
   </build>
 """
 
-/** Builds a child-module pom.xml string (2-space indent). */
+/** Builds a child-module pom.xml string (2-space indent).
+ *  A dependency entry is either a String (an internal module artifactId, inheriting this project's
+ *  groupId and BOM-managed version) or a Map [groupId:…, artifactId:…] for an external dependency. */
 def modulePom = { String gId, String parentAId, String ver,
-                   String aId, String desc, List<String> deps = [], String buildSection = '' ->
+                   String aId, String desc, List deps = [], String buildSection = '' ->
     def depsSection = ''
     if (deps) {
         def lines = deps.collect { dep ->
+            def dGroup = (dep instanceof Map) ? dep.groupId : gId
+            def dArtifact = (dep instanceof Map) ? dep.artifactId : dep
             """\
     <dependency>
-      <groupId>${gId}</groupId>
-      <artifactId>${dep}</artifactId>
+      <groupId>${dGroup}</groupId>
+      <artifactId>${dArtifact}</artifactId>
     </dependency>"""
         }.join('\n')
         depsSection = "\n  <dependencies>\n${lines}\n  </dependencies>\n"
@@ -124,6 +128,7 @@ def pkgPath = pkg.replace('.', '/')
 def integrationsInput      = (props.getProperty('integrations')      ?: '').trim()
 def serviceAreasInput      = (props.getProperty('serviceAreas')      ?: '').trim()
 def presentationTypesInput = (props.getProperty('presentationTypes') ?: 'rest').trim()
+def includeSpring          = ((props.getProperty('includeSpring') ?: 'true').trim().toLowerCase() != 'false')
 
 // ─── Parse Integrations ───────────────────────────────────────────────────────
 //   Input format: "type:name[,type:name,...]"   e.g. "database:users,rest:orders"
@@ -185,6 +190,38 @@ def projectDir = new File(request.outputDirectory)
 def subDir     = new File(projectDir, artifactId)
 if (subDir.isDirectory()) projectDir = subDir
 
+// ─── Spring configuration class generator ─────────────────────────────────────
+// When includeSpring is true, every module the app composes carries a @Configuration
+// class in its `.config` sub-package (the app's Application class @Imports them all)
+// and declares spring-context. Everything here is skipped when includeSpring is false.
+
+def SPRING_CONTEXT = [groupId: 'org.springframework', artifactId: 'spring-context']
+def springCtx = includeSpring ? [SPRING_CONTEXT] : []   // appended to module deps only when Spring is enabled
+def configFqns = []
+
+/** Writes a @Configuration class into {module}/…/{mainSub}/config and records its FQN; no-op when Spring is off. */
+def configClass = { String module, String mainSub ->
+    if (!includeSpring) return null
+    def className = module.split('-').collect { it.capitalize() }.join('') + 'Configuration'
+    def pkgFq = (pkgPath + '/' + mainSub + '/config').replace('/', '.')
+    def dir = "${module}/src/main/java/${pkgPath}/${mainSub}/config"
+    writeFile(projectDir, "${dir}/${className}.java", """\
+package ${pkgFq};
+
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * Spring configuration for the ${module} module.
+ */
+@Configuration
+public class ${className} {
+}
+""")
+    def fqn = "${pkgFq}.${className}".toString()
+    configFqns << fqn
+    return fqn
+}
+
 // ─── parent/pom.xml ───────────────────────────────────────────────────────────
 // Modules listed with "../" relative path; child modules use relativePath back here.
 // The placeholder pom.xml at the project root (generated by the archetype engine)
@@ -201,6 +238,16 @@ def dmXml = allModules.collect { mod ->
       </dependency>"""
 }.join('\n')
 
+def parentInherit = includeSpring ? """\
+  <parent>
+    <groupId>org.springframework.boot</groupId>
+    <artifactId>spring-boot-starter-parent</artifactId>
+    <version>4.0.6</version>
+    <relativePath/>
+  </parent>
+
+""" : ''
+
 def parentPom = """\
 <?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0"
@@ -209,7 +256,7 @@ def parentPom = """\
          https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
 
-  <groupId>${groupId}</groupId>
+${parentInherit}  <groupId>${groupId}</groupId>
   <artifactId>${artifactId}</artifactId>
   <version>${version}</version>
   <packaging>pom</packaging>
@@ -400,10 +447,12 @@ try {
 writeFile(projectDir, 'common-domain/pom.xml',
     modulePom(groupId, artifactId, version,
         'common-domain',
-        'Domain classes common to all modules.'))
+        'Domain classes common to all modules.',
+        springCtx))
 srcTree(projectDir, 'common-domain', pkgPath,
     ['common/domain'], ['common/domain'],
     'Domain classes common to all modules.')
+configClass('common-domain', 'common/domain')
 
 // ─── common-testing ───────────────────────────────────────────────────────────
 
@@ -429,20 +478,22 @@ integrations.each { intg ->
         modulePom(groupId, artifactId, version,
             domMod,
             "Domain classes for the ${intg.name} ${disp} data source.",
-            ['common-domain']))
+            ['common-domain'] + springCtx))
     srcTree(projectDir, domMod, pkgPath,
         [domSub], [domSub],
         "Domain classes for the ${intg.name} ${disp} integration.")
+    configClass(domMod, domSub)
 
     writeFile(projectDir, "${implMod}/pom.xml",
         modulePom(groupId, artifactId, version,
             implMod,
             "Integration classes (DAOs, repositories) for the ${intg.name} ${disp} data source.",
-            ['common-domain', domMod],
+            ['common-domain', domMod] + springCtx,
             failsafeSection))
     srcTree(projectDir, implMod, pkgPath,
         [implSub], [implSub],
         "Integration classes for the ${intg.name} ${disp} data source.")
+    configClass(implMod, implSub)
 }
 
 // ─── Service modules ──────────────────────────────────────────────────────────
@@ -463,15 +514,17 @@ serviceModules.each { svcMod ->
     writeFile(projectDir, "${domMod}/pom.xml",
         modulePom(groupId, artifactId, version,
             domMod, domDesc,
-            ['common-domain']))
+            ['common-domain'] + springCtx))
     srcTree(projectDir, domMod, pkgPath, [domPkg], [domPkg], domDesc)
+    configClass(domMod, domPkg)
 
     // Business logic, depending on its own service-area domain module.
     writeFile(projectDir, "${svcMod}/pom.xml",
         modulePom(groupId, artifactId, version,
             svcMod, svcDesc,
-            ['common-domain', domMod]))
+            ['common-domain', domMod] + springCtx))
     srcTree(projectDir, svcMod, pkgPath, [svcPkg], [svcPkg], svcDesc)
+    configClass(svcMod, svcPkg)
 }
 
 // ─── Presentation: domain-{type} and presentation-{type} ──────────────────────
@@ -485,31 +538,89 @@ presentations.each { pType ->
         modulePom(groupId, artifactId, version,
             domMod,
             "Domain classes for the ${disp} presentation tier.",
-            ['common-domain']))
+            ['common-domain'] + springCtx))
     srcTree(projectDir, domMod, pkgPath,
         ["domain/${pType}"], ["domain/${pType}"],
         "Domain classes for the ${disp} presentation tier.")
+    configClass(domMod, "domain/${pType}")
 
     writeFile(projectDir, "${implMod}/pom.xml",
         modulePom(groupId, artifactId, version,
             implMod,
             "Request-handling classes (controllers) for the ${disp} presentation tier.",
-            ['common-domain', domMod]))
+            ['common-domain', domMod] + springCtx))
     srcTree(projectDir, implMod, pkgPath,
         ["presentation/${pType}"], ["presentation/${pType}"],
         "Request-handling classes for the ${disp} presentation tier.")
+    configClass(implMod, "presentation/${pType}")
 }
 
 // ─── app ─────────────────────────────────────────────────────────────────────
 
+def appStarters = includeSpring ? [
+    [groupId: 'org.springframework.boot', artifactId: 'spring-boot-starter-web'],
+    [groupId: 'org.springframework.boot', artifactId: 'spring-boot-starter-data-jpa'],
+] : []
 writeFile(projectDir, 'app/pom.xml',
     modulePom(groupId, artifactId, version,
         'app',
         'Application assembly — produces the runnable artifact.',
-        appDeps))
+        appDeps + appStarters))
 srcTree(projectDir, 'app', pkgPath, ['app'], ['app'],
     'Application assembly and entry point.')
 
+if (includeSpring) {
+// Spring Boot entry-point classes live in the app's .config package and @Import every
+// module's @Configuration class so the whole tree is assembled into one context.
+def appConfigPkg = (pkgPath + '/app/config').replace('/', '.')
+def importsBlock = configFqns.sort().collect { "    ${it}.class," }.join('\n')
+writeFile(projectDir, "app/src/main/java/${pkgPath}/app/config/Application.java", """\
+package ${appConfigPkg};
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.Import;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+/**
+ * Spring Boot main application class for running standalone in Boot configured embedded container. Not used with WAR
+ * deployment.
+ */
+@SpringBootApplication
+@EnableTransactionManagement
+@Import({
+${importsBlock}
+})
+public class Application {
+    public static void main(final String[] args) {
+        SpringApplication.run(Application.class, args);
+    }
+}
+""")
+writeFile(projectDir, "app/src/main/java/${pkgPath}/app/config/AppServletInitializer.java", """\
+package ${appConfigPkg};
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.builder.SpringApplicationBuilder;
+import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
+
+/**
+ * web.xml configuration replacement for WAR deployment.
+ */
+public class AppServletInitializer extends SpringBootServletInitializer {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+
+    @Override
+    protected SpringApplicationBuilder configure(final SpringApplicationBuilder builder) {
+        log.info("Starting application");
+        return builder.sources(Application.class);
+    }
+}
+""")
+}
+
 // ─── acceptance-tests ─────────────────────────────────────────────────────────
 
 writeFile(projectDir, 'acceptance-tests/pom.xml',

src/main/resources/META-INF/maven/archetype-metadata.xml

@@ -56,6 +56,15 @@
       <!-- Comma-separated types, e.g. rest,graphql -->
     </requiredProperty>
 
+    <requiredProperty key="includeSpring">
+      <defaultValue>true</defaultValue>
+      <!-- true (default): generate the Spring Boot wiring — parent inherits
+           spring-boot-starter-parent, every app-composed module gets a @Configuration
+           class and spring-context, and app gets the Application / AppServletInitializer
+           classes plus the web and data-jpa starters.
+           false: omit all Spring artifacts (configs, classes, and pom items). -->
+    </requiredProperty>
+
   </requiredProperties>
 
   <!--

src/site/asciidoc/modules.adoc

@@ -8,6 +8,10 @@ Every module contains a full `src/` scaffold
 with a `package-info.java` in each module's primary leaf package under both
 `src/main/java` and `src/test/java`.
 
+Every module that the `app` composes also carries a Spring `@Configuration` class in a
+`.config` sub-package; the `app` module's `Application` class `@Import`s them all so the
+whole tree assembles into a single Spring context.
+
 == Fixed Modules
 
 These modules are always generated regardless of input.
@@ -37,8 +41,11 @@ _Depends on_: `common-domain`
 
 `app`::
 Application assembly — produces the runnable artifact (e.g. Spring Boot über-jar).
+Contains the Spring Boot `Application` (`@SpringBootApplication`) and `AppServletInitializer`
+(WAR deployment) classes in `{base.package}.app.config`, and adds the
+`spring-boot-starter-web` and `spring-boot-starter-data-jpa` dependencies.
 +
-_Package_: `{base.package}.app` +
+_Package_: `{base.package}.app`, `{base.package}.app.config` +
 _Depends on_: all non-test modules (`common-domain`, all domain and integration modules,
 all service modules and their `domain-service` modules, all presentation modules)
 
@@ -94,6 +101,7 @@ There is no `pom.xml` at the project root — `parent/` is a sibling of all othe
 
 It contains:
 
+* `<parent>` — inherits `spring-boot-starter-parent` (4.0.6) via an empty `<relativePath/>`, supplying Spring dependency management and plugin defaults
 * `<packaging>pom</packaging>`
 * `<modules>` — all sibling modules referenced as `../module` relative paths, sorted alphabetically
 * `<dependencyManagement>` — all modules pinned to `${project.version}`, sorted alphabetically by `artifactId`

src/site/asciidoc/requirements.adoc

@@ -43,6 +43,17 @@ Prompt for a comma-separated list of presentation-tier types
 * Leave blank (or provide only blank entries) to generate a project with no
   presentation modules.
 
+=== `includeSpring` (default: `true`)
+
+Whether to generate the Spring Boot wiring.
+
+* `true` (default): the `parent/` POM inherits `spring-boot-starter-parent`, every
+  app-composed module carries a `@Configuration` class and `spring-context`, and `app`
+  gets the `Application` / `AppServletInitializer` classes plus the
+  `spring-boot-starter-web` and `spring-boot-starter-data-jpa` dependencies.
+* `false`: omit all Spring artifacts — configs, classes, and POM items — producing a
+  plain multi-module Java project with the same module structure.
+
 == Module Structure
 
 Generate all modules as siblings of a `parent/` directory.
@@ -55,6 +66,9 @@ Do not create a `pom.xml` at the project root.
   sorted alphabetically.
 * List every sibling module in `<dependencyManagement>` pinned to
   `${project.version}`, sorted alphabetically by `artifactId`.
+* Inherit `spring-boot-starter-parent` (version 4.0.6) as the parent POM — via `<parent>`
+  with an empty `<relativePath/>`, not a BOM import — so Spring artifact versions and
+  sensible plugin defaults are managed centrally.
 * Properties: Java 21 via `maven.compiler.release`; UTF-8 source encoding via
   `project.build.sourceEncoding`.
 * `<pluginManagement>` — declare pinned versions for `maven-compiler-plugin`,
@@ -120,7 +134,11 @@ For each presentation type, generate two modules
 
 Assembles the runnable artifact (e.g. Spring Boot uber jar).
 Depend on all generated modules except `acceptance-tests`, `common-testing`,
-and `app` itself.
+and `app` itself, plus `spring-boot-starter-web` and `spring-boot-starter-data-jpa`.
+Contains the Spring Boot `Application` (`@SpringBootApplication`,
+`@EnableTransactionManagement`) and `AppServletInitializer` (WAR deployment)
+classes in the `.config` sub-package. `Application` `@Import`s the `@Configuration`
+class that every app-composed module carries in its own `.config` sub-package.
 
 === `acceptance-tests`
 
@@ -138,7 +156,8 @@ Functional tests that exercise the application end-to-end.
 Each module's source root is the package derived from the base package prompt.
 Place a `package-info.java` in each module's primary leaf package under both
 `src/main/java` and `src/test/java`, with a Javadoc comment describing the package's
-purpose; the test-side comment is prefixed with "Tests for ...".
+purpose; the test-side comment is prefixed with "Tests for ...". Each app-composed
+module additionally carries a `@Configuration` class in a `.config` sub-package.
 The package for each module is:
 
 [cols="1,1"]

src/test/resources/projects/basic/verify.groovy

@@ -240,11 +240,15 @@ def psScript = text('parent/mvn-update-properties-versions.ps1')
 assert psScript.contains('mvn versions:update-properties')      : 'PowerShell script must run mvn versions:update-properties'
 assert psScript.contains('\r\n')                               : 'PowerShell script must use CRLF line endings'
 
-// ── #8 service-area domain module ────────────────────────────────────────────
+// ── #8 service-area domain module + #4 Spring Boot wiring ────────────────────
 
 check('domain-service/pom.xml')
 assert text('domain-service/pom.xml').contains('<artifactId>common-domain</artifactId>') : 'domain-service missing common-domain dep'
 assert text('service/pom.xml').contains('<artifactId>domain-service</artifactId>')       : 'service must depend on domain-service'
+check("app/src/main/java/${p}/app/config/Application.java")
+check("app/src/main/java/${p}/app/config/AppServletInitializer.java")
+assert parentPom.contains('<artifactId>spring-boot-starter-parent</artifactId>') : 'parent must inherit spring-boot-starter-parent'
+assert appPom.contains('<artifactId>spring-boot-starter-web</artifactId>')     : 'app must depend on spring-boot-starter-web'
 
 _buildLog.append("\n=== PASSED ===\n")
 true

src/test/resources/projects/full/archetype.properties

@@ -5,3 +5,4 @@ package=com.example.full
 integrations=database:users,graphql:catalog
 serviceAreas=orders,notifications
 presentationTypes=rest,graphql
+includeSpring=true