@xpertss/projen-types 0.0.13 → 0.0.14

package/lib/java/java-spring-boot-project.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JavaSpringBootProject = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const java_maven_base_1 = require("./java-maven-base");
+const java_versions_1 = require("./java-versions");
+const maven_pom_1 = require("./maven/maven-pom");
+const REPACKAGE = { executions: [{ id: 'repackage', goals: ['repackage'] }] };
+/**
+ * Spring Boot on Maven, single- or multi-module, with no Docker, Flyway or
+ * CDK - `JavaMavenProject` plus Spring Boot dependency management.
+ *
+ * - `spring-boot-dependencies` is imported as the first BOM, so starters and
+ *   the libraries Boot manages (JUnit included) are added versionless.
+ * - `spring-boot-maven-plugin` is versioned in `<pluginManagement>`. A
+ *   single-module project repackages its root jar into an executable one.
+ *   In a multi-module project only modules added with
+ *   `addSpringBootModule()` are repackaged; `addModule()` modules stay plain
+ *   jars (shared libraries, clients, ...).
+ *
+ * `JavaServiceProject` builds on this and adds Docker publishing, Flyway,
+ * and a CDK deploy hook.
+ */
+class JavaSpringBootProject extends java_maven_base_1.JavaMavenProject {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@xpertss/projen-types.JavaSpringBootProject", version: "0.0.14" };
+    /** The Spring Boot version (BOM and Maven plugin). */
+    springBootVersion;
+    constructor(options) {
+        super(options);
+        const version = options.springBootVersion ?? this.pinnedVersion(java_versions_1.SPRING_BOOT_BOM);
+        (0, maven_pom_1.assertExactVersion)(version, 'springBootVersion');
+        const major = parseInt(version.split('.')[0], 10);
+        const maxMajor = this.maxSpringBootMajor();
+        if (maxMajor !== undefined && major > maxMajor) {
+            throw new Error(`Spring Boot ${version} does not run on javaVersion ${this.javaVersion} (the newest Spring Boot line for it is ${maxMajor}.x). Use a ${maxMajor}.x springBootVersion, or a newer javaVersion.`);
+        }
+        this.springBootVersion = version;
+        // Boot's BOM manages JUnit, so the base type's junit-bom would only
+        // compete with it.
+        this.pom.removeBom(java_versions_1.JUNIT_BOM);
+        this.pom.addBom(`${java_versions_1.SPRING_BOOT_BOM}@${version}`);
+        this.pom.addManagedPlugin(`${java_versions_1.SPRING_BOOT_MAVEN_PLUGIN}@${version}`);
+        // A repackaged jar no longer exposes its classes at the top level, so
+        // failsafe tests against the compiled classes, as spring-boot-starter-
+        // parent configures it.
+        this.addPlugin(java_versions_1.MAVEN_FAILSAFE_PLUGIN, {
+            configuration: { classesDirectory: '${project.build.outputDirectory}' },
+        });
+    }
+    /**
+     * Adds a module that is a Spring Boot application: like `addModule()`, plus
+     * `spring-boot-maven-plugin`'s `repackage`, which turns the module's jar
+     * into an executable one.
+     */
+    addSpringBootModule(options) {
+        const module = this.addModule(options);
+        module.addPlugin(java_versions_1.SPRING_BOOT_MAVEN_PLUGIN, REPACKAGE);
+        return module;
+    }
+    preSynthesize() {
+        super.preSynthesize();
+        if (this.modules.length === 0 && !this.pom.hasPlugin(java_versions_1.SPRING_BOOT_MAVEN_PLUGIN)) {
+            this.addPlugin(java_versions_1.SPRING_BOOT_MAVEN_PLUGIN, REPACKAGE);
+        }
+    }
+}
+exports.JavaSpringBootProject = JavaSpringBootProject;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/java/java-versions.d.ts

@@ -0,0 +1,40 @@
+/** `groupId/artifactId` keys for the versions this package pins by default. */
+export declare const MAVEN_COMPILER_PLUGIN = "org.apache.maven.plugins/maven-compiler-plugin";
+export declare const MAVEN_SUREFIRE_PLUGIN = "org.apache.maven.plugins/maven-surefire-plugin";
+export declare const MAVEN_FAILSAFE_PLUGIN = "org.apache.maven.plugins/maven-failsafe-plugin";
+export declare const MAVEN_JAR_PLUGIN = "org.apache.maven.plugins/maven-jar-plugin";
+export declare const MAVEN_ENFORCER_PLUGIN = "org.apache.maven.plugins/maven-enforcer-plugin";
+export declare const MAVEN_JAVADOC_PLUGIN = "org.apache.maven.plugins/maven-javadoc-plugin";
+export declare const MAVEN_SOURCE_PLUGIN = "org.apache.maven.plugins/maven-source-plugin";
+export declare const JUNIT_BOM = "org.junit/junit-bom";
+export declare const SPRING_BOOT_BOM = "org.springframework.boot/spring-boot-dependencies";
+export declare const SPRING_BOOT_MAVEN_PLUGIN = "org.springframework.boot/spring-boot-maven-plugin";
+export declare const FLYWAY_MAVEN_PLUGIN = "org.flywaydb/flyway-maven-plugin";
+export declare const VERSIONS_MAVEN_PLUGIN = "org.codehaus.mojo/versions-maven-plugin";
+/** The Java line used when a project sets no `javaVersion`. */
+export declare const DEFAULT_JAVA_VERSION = "21";
+/** The minimum Maven version the enforcer requires by default. */
+export declare const DEFAULT_MIN_MAVEN_VERSION = "3.9";
+/** Everything a generated build derives from its Java line. */
+export interface JavaLineProfile {
+    /** Canonical line id, as written in `javaVersion` (`1.8`, `17`, ...). */
+    readonly line: string;
+    /** `<properties>` that set the compiler level. */
+    readonly compilerProperties: Record<string, string>;
+    /** The enforcer's `requireJavaVersion` range. */
+    readonly enforcerJavaRange: string;
+    /** `actions/setup-java`'s `java-version` input. */
+    readonly setupJavaVersion: string;
+    /** Default exact versions, keyed by `groupId/artifactId`. */
+    readonly versions: Record<string, string>;
+    /** Newest Spring Boot major that runs on this line, if it is capped. */
+    readonly maxSpringBootMajor?: number;
+}
+/** The Java lines `javaVersion` accepts, in ascending order. */
+export declare function supportedJavaVersions(): string[];
+/**
+ * Resolves a `javaVersion` option to its line profile, applying
+ * `versionOverrides` (`groupId/artifactId` -> exact version) on top of the
+ * line's defaults. Throws, listing the supported lines, on an unknown line.
+ */
+export declare function resolveJavaLine(javaVersion: string | undefined, versionOverrides?: Record<string, string>): JavaLineProfile;

package/lib/java/java-versions.js

@@ -0,0 +1,106 @@
+"use strict";
+// Every Java-line-dependent value a generated Maven build uses lives in this
+// file, grouped by Java line (F013 §4). Nothing else in `src/java` may
+// hard-code a Java version or a default plugin/BOM version - adding a Java
+// line is one new entry in JAVA_LINES. Versions are exact pins, verified
+// against Maven Central (and, for plugins, run on the oldest JDK of the line
+// they are listed for) when they were last bumped.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MIN_MAVEN_VERSION = exports.DEFAULT_JAVA_VERSION = exports.VERSIONS_MAVEN_PLUGIN = exports.FLYWAY_MAVEN_PLUGIN = exports.SPRING_BOOT_MAVEN_PLUGIN = exports.SPRING_BOOT_BOM = exports.JUNIT_BOM = exports.MAVEN_SOURCE_PLUGIN = exports.MAVEN_JAVADOC_PLUGIN = exports.MAVEN_ENFORCER_PLUGIN = exports.MAVEN_JAR_PLUGIN = exports.MAVEN_FAILSAFE_PLUGIN = exports.MAVEN_SUREFIRE_PLUGIN = exports.MAVEN_COMPILER_PLUGIN = void 0;
+exports.supportedJavaVersions = supportedJavaVersions;
+exports.resolveJavaLine = resolveJavaLine;
+/** `groupId/artifactId` keys for the versions this package pins by default. */
+exports.MAVEN_COMPILER_PLUGIN = 'org.apache.maven.plugins/maven-compiler-plugin';
+exports.MAVEN_SUREFIRE_PLUGIN = 'org.apache.maven.plugins/maven-surefire-plugin';
+exports.MAVEN_FAILSAFE_PLUGIN = 'org.apache.maven.plugins/maven-failsafe-plugin';
+exports.MAVEN_JAR_PLUGIN = 'org.apache.maven.plugins/maven-jar-plugin';
+exports.MAVEN_ENFORCER_PLUGIN = 'org.apache.maven.plugins/maven-enforcer-plugin';
+exports.MAVEN_JAVADOC_PLUGIN = 'org.apache.maven.plugins/maven-javadoc-plugin';
+exports.MAVEN_SOURCE_PLUGIN = 'org.apache.maven.plugins/maven-source-plugin';
+exports.JUNIT_BOM = 'org.junit/junit-bom';
+exports.SPRING_BOOT_BOM = 'org.springframework.boot/spring-boot-dependencies';
+exports.SPRING_BOOT_MAVEN_PLUGIN = 'org.springframework.boot/spring-boot-maven-plugin';
+exports.FLYWAY_MAVEN_PLUGIN = 'org.flywaydb/flyway-maven-plugin';
+exports.VERSIONS_MAVEN_PLUGIN = 'org.codehaus.mojo/versions-maven-plugin';
+/** The Java line used when a project sets no `javaVersion`. */
+exports.DEFAULT_JAVA_VERSION = '21';
+/** The minimum Maven version the enforcer requires by default. */
+exports.DEFAULT_MIN_MAVEN_VERSION = '3.9';
+// Maven plugins that run on every supported JDK (all of them require only
+// Java 8 at runtime), so they are shared by every line.
+const SHARED_PLUGIN_VERSIONS = {
+    [exports.MAVEN_COMPILER_PLUGIN]: '3.16.0',
+    [exports.MAVEN_SUREFIRE_PLUGIN]: '3.6.0',
+    [exports.MAVEN_FAILSAFE_PLUGIN]: '3.6.0',
+    [exports.MAVEN_JAR_PLUGIN]: '3.5.1',
+    [exports.MAVEN_ENFORCER_PLUGIN]: '3.6.3',
+    [exports.MAVEN_JAVADOC_PLUGIN]: '3.12.0',
+    [exports.MAVEN_SOURCE_PLUGIN]: '3.4.0',
+    [exports.VERSIONS_MAVEN_PLUGIN]: '2.22.0',
+};
+// Libraries whose current major needs Java 17: JUnit 6, Spring Boot 3+/4,
+// Flyway 10+. The Java 8 line stays on the last major that supports it.
+const MODERN_VERSIONS = {
+    ...SHARED_PLUGIN_VERSIONS,
+    [exports.JUNIT_BOM]: '6.1.3',
+    [exports.SPRING_BOOT_BOM]: '4.1.1',
+    [exports.FLYWAY_MAVEN_PLUGIN]: '13.9.0',
+};
+const JAVA_LINES = {
+    1.8: {
+        line: '1.8',
+        // javac 8 has no --release flag; source/target is the only option.
+        compilerProperties: {
+            'maven.compiler.source': '1.8',
+            'maven.compiler.target': '1.8',
+        },
+        enforcerJavaRange: '[1.8,)',
+        setupJavaVersion: '8',
+        // Spring Boot 3+ needs Java 17.
+        maxSpringBootMajor: 2,
+        versions: {
+            ...SHARED_PLUGIN_VERSIONS,
+            [exports.JUNIT_BOM]: '5.14.4',
+            [exports.SPRING_BOOT_BOM]: '2.7.18',
+            [exports.FLYWAY_MAVEN_PLUGIN]: '9.22.3',
+        },
+    },
+    ...modernLine('17'),
+    ...modernLine('21'),
+    ...modernLine('25'),
+};
+function modernLine(line) {
+    return {
+        [line]: {
+            line,
+            compilerProperties: { 'maven.compiler.release': line },
+            enforcerJavaRange: `[${line},)`,
+            setupJavaVersion: line,
+            versions: MODERN_VERSIONS,
+        },
+    };
+}
+const ALIASES = { 8: '1.8' };
+/** The Java lines `javaVersion` accepts, in ascending order. */
+function supportedJavaVersions() {
+    // Integer-like keys ('17') enumerate before '1.8', so sort explicitly.
+    return Object.keys(JAVA_LINES).sort((a, b) => parseFloat(a) - parseFloat(b));
+}
+/**
+ * Resolves a `javaVersion` option to its line profile, applying
+ * `versionOverrides` (`groupId/artifactId` -> exact version) on top of the
+ * line's defaults. Throws, listing the supported lines, on an unknown line.
+ */
+function resolveJavaLine(javaVersion, versionOverrides = {}) {
+    const requested = javaVersion ?? exports.DEFAULT_JAVA_VERSION;
+    const key = ALIASES[requested] ?? requested;
+    const profile = JAVA_LINES[key];
+    if (!profile) {
+        throw new Error(`Unsupported javaVersion "${requested}". Supported: ${supportedJavaVersions().join(', ')}.`);
+    }
+    return {
+        ...profile,
+        versions: { ...profile.versions, ...versionOverrides },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"java-versions.js","sourceRoot":"","sources":["../../src/java/java-versions.ts"],"names":[],"mappings":"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","sourcesContent":["// Every Java-line-dependent value a generated Maven build uses lives in this\n// file, grouped by Java line (F013 §4). Nothing else in `src/java` may\n// hard-code a Java version or a default plugin/BOM version - adding a Java\n// line is one new entry in JAVA_LINES. Versions are exact pins, verified\n// against Maven Central (and, for plugins, run on the oldest JDK of the line\n// they are listed for) when they were last bumped.\n\n/** `groupId/artifactId` keys for the versions this package pins by default. */\nexport const MAVEN_COMPILER_PLUGIN = 'org.apache.maven.plugins/maven-compiler-plugin';\nexport const MAVEN_SUREFIRE_PLUGIN = 'org.apache.maven.plugins/maven-surefire-plugin';\nexport const MAVEN_FAILSAFE_PLUGIN = 'org.apache.maven.plugins/maven-failsafe-plugin';\nexport const MAVEN_JAR_PLUGIN = 'org.apache.maven.plugins/maven-jar-plugin';\nexport const MAVEN_ENFORCER_PLUGIN = 'org.apache.maven.plugins/maven-enforcer-plugin';\nexport const MAVEN_JAVADOC_PLUGIN = 'org.apache.maven.plugins/maven-javadoc-plugin';\nexport const MAVEN_SOURCE_PLUGIN = 'org.apache.maven.plugins/maven-source-plugin';\nexport const JUNIT_BOM = 'org.junit/junit-bom';\nexport const SPRING_BOOT_BOM = 'org.springframework.boot/spring-boot-dependencies';\nexport const SPRING_BOOT_MAVEN_PLUGIN = 'org.springframework.boot/spring-boot-maven-plugin';\nexport const FLYWAY_MAVEN_PLUGIN = 'org.flywaydb/flyway-maven-plugin';\nexport const VERSIONS_MAVEN_PLUGIN = 'org.codehaus.mojo/versions-maven-plugin';\n\n/** The Java line used when a project sets no `javaVersion`. */\nexport const DEFAULT_JAVA_VERSION = '21';\n\n/** The minimum Maven version the enforcer requires by default. */\nexport const DEFAULT_MIN_MAVEN_VERSION = '3.9';\n\n// Maven plugins that run on every supported JDK (all of them require only\n// Java 8 at runtime), so they are shared by every line.\nconst SHARED_PLUGIN_VERSIONS: Record<string, string> = {\n  [MAVEN_COMPILER_PLUGIN]: '3.16.0',\n  [MAVEN_SUREFIRE_PLUGIN]: '3.6.0',\n  [MAVEN_FAILSAFE_PLUGIN]: '3.6.0',\n  [MAVEN_JAR_PLUGIN]: '3.5.1',\n  [MAVEN_ENFORCER_PLUGIN]: '3.6.3',\n  [MAVEN_JAVADOC_PLUGIN]: '3.12.0',\n  [MAVEN_SOURCE_PLUGIN]: '3.4.0',\n  [VERSIONS_MAVEN_PLUGIN]: '2.22.0',\n};\n\n// Libraries whose current major needs Java 17: JUnit 6, Spring Boot 3+/4,\n// Flyway 10+. The Java 8 line stays on the last major that supports it.\nconst MODERN_VERSIONS: Record<string, string> = {\n  ...SHARED_PLUGIN_VERSIONS,\n  [JUNIT_BOM]: '6.1.3',\n  [SPRING_BOOT_BOM]: '4.1.1',\n  [FLYWAY_MAVEN_PLUGIN]: '13.9.0',\n};\n\n/** Everything a generated build derives from its Java line. */\nexport interface JavaLineProfile {\n  /** Canonical line id, as written in `javaVersion` (`1.8`, `17`, ...). */\n  readonly line: string;\n  /** `<properties>` that set the compiler level. */\n  readonly compilerProperties: Record<string, string>;\n  /** The enforcer's `requireJavaVersion` range. */\n  readonly enforcerJavaRange: string;\n  /** `actions/setup-java`'s `java-version` input. */\n  readonly setupJavaVersion: string;\n  /** Default exact versions, keyed by `groupId/artifactId`. */\n  readonly versions: Record<string, string>;\n  /** Newest Spring Boot major that runs on this line, if it is capped. */\n  readonly maxSpringBootMajor?: number;\n}\n\nconst JAVA_LINES: Record<string, JavaLineProfile> = {\n  1.8: {\n    line: '1.8',\n    // javac 8 has no --release flag; source/target is the only option.\n    compilerProperties: {\n      'maven.compiler.source': '1.8',\n      'maven.compiler.target': '1.8',\n    },\n    enforcerJavaRange: '[1.8,)',\n    setupJavaVersion: '8',\n    // Spring Boot 3+ needs Java 17.\n    maxSpringBootMajor: 2,\n    versions: {\n      ...SHARED_PLUGIN_VERSIONS,\n      [JUNIT_BOM]: '5.14.4',\n      [SPRING_BOOT_BOM]: '2.7.18',\n      [FLYWAY_MAVEN_PLUGIN]: '9.22.3',\n    },\n  },\n  ...modernLine('17'),\n  ...modernLine('21'),\n  ...modernLine('25'),\n};\n\nfunction modernLine(line: string): Record<string, JavaLineProfile> {\n  return {\n    [line]: {\n      line,\n      compilerProperties: { 'maven.compiler.release': line },\n      enforcerJavaRange: `[${line},)`,\n      setupJavaVersion: line,\n      versions: MODERN_VERSIONS,\n    },\n  };\n}\n\nconst ALIASES: Record<string, string> = { 8: '1.8' };\n\n/** The Java lines `javaVersion` accepts, in ascending order. */\nexport function supportedJavaVersions(): string[] {\n  // Integer-like keys ('17') enumerate before '1.8', so sort explicitly.\n  return Object.keys(JAVA_LINES).sort((a, b) => parseFloat(a) - parseFloat(b));\n}\n\n/**\n * Resolves a `javaVersion` option to its line profile, applying\n * `versionOverrides` (`groupId/artifactId` -> exact version) on top of the\n * line's defaults. Throws, listing the supported lines, on an unknown line.\n */\nexport function resolveJavaLine(\n  javaVersion: string | undefined,\n  versionOverrides: Record<string, string> = {},\n): JavaLineProfile {\n  const requested = javaVersion ?? DEFAULT_JAVA_VERSION;\n  const key = ALIASES[requested] ?? requested;\n  const profile = JAVA_LINES[key];\n  if (!profile) {\n    throw new Error(\n      `Unsupported javaVersion \"${requested}\". Supported: ${supportedJavaVersions().join(', ')}.`,\n    );\n  }\n  return {\n    ...profile,\n    versions: { ...profile.versions, ...versionOverrides },\n  };\n}\n"]}

package/lib/java/maven/maven-module.d.ts

@@ -0,0 +1,47 @@
+import { Component, Project, java } from 'projen';
+import { MavenPom } from './maven-pom';
+import { MavenModuleOptions } from '../options';
+/**
+ * One module of a Maven reactor: a `<dir>/pom.xml` owned by the root
+ * project (not a projen subproject - there is still one `.projen/`, one
+ * `.gitignore` and one `tasks.json`). Created by `JavaMavenProject.addModule()`.
+ *
+ * The module pom holds `<parent>`, `artifactId`, `name`, `description` and
+ * versionless dependencies/plugins. Any version given to `addDependency`,
+ * `addTestDependency` or `addPlugin` is moved into the parent pom's
+ * `<dependencyManagement>`/`<pluginManagement>`, so every module that uses
+ * an artifact gets the same version.
+ */
+export declare class MavenModule extends Component {
+    /** Module directory, relative to the repo root. */
+    readonly dir: string;
+    readonly artifactId: string;
+    /** The module's own `pom.xml`. */
+    readonly pom: MavenPom;
+    private readonly parentPom;
+    private readonly groupId;
+    constructor(project: Project, parentPom: MavenPom, options: MavenModuleOptions);
+    /**
+     * Adds a compile-scope dependency. A version, if given, is pinned in the
+     * parent's `<dependencyManagement>` and the module entry stays versionless.
+     *
+     * @param spec `groupId/artifactId[@version]`
+     */
+    addDependency(spec: string): void;
+    /** Adds a `test`-scoped dependency; versions are hoisted like `addDependency`. */
+    addTestDependency(spec: string): void;
+    /**
+     * Adds a build plugin. A version, if given, is pinned in the parent's
+     * `<pluginManagement>` and the module entry stays versionless.
+     */
+    addPlugin(spec: string, options?: java.PluginOptions): void;
+    /**
+     * Depends on a sibling module. The dependency is versionless here; the
+     * parent manages every module at `${project.version}`.
+     *
+     * @param scope Maven scope (`test`, `provided`, ...)
+     * @default - compile scope
+     */
+    addModuleDependency(module: MavenModule, scope?: string): void;
+    private hoistDependency;
+}

package/lib/java/maven/maven-module.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MavenModule = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const projen_1 = require("projen");
+const maven_pom_1 = require("./maven-pom");
+/**
+ * One module of a Maven reactor: a `<dir>/pom.xml` owned by the root
+ * project (not a projen subproject - there is still one `.projen/`, one
+ * `.gitignore` and one `tasks.json`). Created by `JavaMavenProject.addModule()`.
+ *
+ * The module pom holds `<parent>`, `artifactId`, `name`, `description` and
+ * versionless dependencies/plugins. Any version given to `addDependency`,
+ * `addTestDependency` or `addPlugin` is moved into the parent pom's
+ * `<dependencyManagement>`/`<pluginManagement>`, so every module that uses
+ * an artifact gets the same version.
+ */
+class MavenModule extends projen_1.Component {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@xpertss/projen-types.MavenModule", version: "0.0.14" };
+    /** Module directory, relative to the repo root. */
+    dir;
+    artifactId;
+    /** The module's own `pom.xml`. */
+    pom;
+    parentPom;
+    groupId;
+    constructor(project, parentPom, options) {
+        super(project);
+        if (!parentPom.groupId || !parentPom.version) {
+            throw new Error('A module parent pom needs a groupId and version.');
+        }
+        this.dir = options.dir;
+        this.artifactId = options.artifactId;
+        this.parentPom = parentPom;
+        this.groupId = parentPom.groupId;
+        const depth = options.dir.split('/').length;
+        this.pom = new maven_pom_1.MavenPom(project, {
+            filePath: `${options.dir}/pom.xml`,
+            artifactId: options.artifactId,
+            packaging: options.packaging,
+            name: options.name ?? options.artifactId,
+            description: options.description,
+            parent: {
+                groupId: parentPom.groupId,
+                artifactId: parentPom.artifactId,
+                // Maven does not interpolate the <parent> block, so this is the
+                // literal parent version, not ${project.version}.
+                version: parentPom.version,
+                relativePath: `${'../'.repeat(depth)}pom.xml`,
+            },
+        });
+    }
+    /**
+     * Adds a compile-scope dependency. A version, if given, is pinned in the
+     * parent's `<dependencyManagement>` and the module entry stays versionless.
+     *
+     * @param spec `groupId/artifactId[@version]`
+     */
+    addDependency(spec) {
+        this.pom.addDependency(this.hoistDependency(spec));
+    }
+    /** Adds a `test`-scoped dependency; versions are hoisted like `addDependency`. */
+    addTestDependency(spec) {
+        this.pom.addTestDependency(this.hoistDependency(spec));
+    }
+    /**
+     * Adds a build plugin. A version, if given, is pinned in the parent's
+     * `<pluginManagement>` and the module entry stays versionless.
+     */
+    addPlugin(spec, options = {}) {
+        const c = (0, maven_pom_1.parseMavenSpec)(spec);
+        if (c.version) {
+            this.parentPom.addManagedPlugin(spec);
+        }
+        this.pom.addPlugin(`${c.groupId}/${c.artifactId}`, options);
+    }
+    /**
+     * Depends on a sibling module. The dependency is versionless here; the
+     * parent manages every module at `${project.version}`.
+     *
+     * @param scope Maven scope (`test`, `provided`, ...)
+     * @default - compile scope
+     */
+    addModuleDependency(module, scope) {
+        if (module === this) {
+            throw new Error(`Module "${this.artifactId}" cannot depend on itself.`);
+        }
+        this.pom.addDependency(`${this.groupId}/${module.artifactId}`, scope);
+    }
+    hoistDependency(spec) {
+        const c = (0, maven_pom_1.parseMavenSpec)(spec);
+        if (c.version) {
+            this.parentPom.addManagedDependency(spec);
+        }
+        return `${c.groupId}/${c.artifactId}`;
+    }
+}
+exports.MavenModule = MavenModule;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"maven-module.js","sourceRoot":"","sources":["../../../src/java/maven/maven-module.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Project, java } from 'projen';\nimport { MavenPom, parseMavenSpec } from './maven-pom';\nimport { MavenModuleOptions } from '../options';\n\n/**\n * One module of a Maven reactor: a `<dir>/pom.xml` owned by the root\n * project (not a projen subproject - there is still one `.projen/`, one\n * `.gitignore` and one `tasks.json`). Created by `JavaMavenProject.addModule()`.\n *\n * The module pom holds `<parent>`, `artifactId`, `name`, `description` and\n * versionless dependencies/plugins. Any version given to `addDependency`,\n * `addTestDependency` or `addPlugin` is moved into the parent pom's\n * `<dependencyManagement>`/`<pluginManagement>`, so every module that uses\n * an artifact gets the same version.\n */\nexport class MavenModule extends Component {\n  /** Module directory, relative to the repo root. */\n  public readonly dir: string;\n  public readonly artifactId: string;\n  /** The module's own `pom.xml`. */\n  public readonly pom: MavenPom;\n\n  private readonly parentPom: MavenPom;\n  private readonly groupId: string;\n\n  constructor(project: Project, parentPom: MavenPom, options: MavenModuleOptions) {\n    super(project);\n    if (!parentPom.groupId || !parentPom.version) {\n      throw new Error('A module parent pom needs a groupId and version.');\n    }\n    this.dir = options.dir;\n    this.artifactId = options.artifactId;\n    this.parentPom = parentPom;\n    this.groupId = parentPom.groupId;\n\n    const depth = options.dir.split('/').length;\n    this.pom = new MavenPom(project, {\n      filePath: `${options.dir}/pom.xml`,\n      artifactId: options.artifactId,\n      packaging: options.packaging,\n      name: options.name ?? options.artifactId,\n      description: options.description,\n      parent: {\n        groupId: parentPom.groupId,\n        artifactId: parentPom.artifactId,\n        // Maven does not interpolate the <parent> block, so this is the\n        // literal parent version, not ${project.version}.\n        version: parentPom.version,\n        relativePath: `${'../'.repeat(depth)}pom.xml`,\n      },\n    });\n  }\n\n  /**\n   * Adds a compile-scope dependency. A version, if given, is pinned in the\n   * parent's `<dependencyManagement>` and the module entry stays versionless.\n   *\n   * @param spec `groupId/artifactId[@version]`\n   */\n  public addDependency(spec: string): void {\n    this.pom.addDependency(this.hoistDependency(spec));\n  }\n\n  /** Adds a `test`-scoped dependency; versions are hoisted like `addDependency`. */\n  public addTestDependency(spec: string): void {\n    this.pom.addTestDependency(this.hoistDependency(spec));\n  }\n\n  /**\n   * Adds a build plugin. A version, if given, is pinned in the parent's\n   * `<pluginManagement>` and the module entry stays versionless.\n   */\n  public addPlugin(spec: string, options: java.PluginOptions = {}): void {\n    const c = parseMavenSpec(spec);\n    if (c.version) {\n      this.parentPom.addManagedPlugin(spec);\n    }\n    this.pom.addPlugin(`${c.groupId}/${c.artifactId}`, options);\n  }\n\n  /**\n   * Depends on a sibling module. The dependency is versionless here; the\n   * parent manages every module at `${project.version}`.\n   *\n   * @param scope Maven scope (`test`, `provided`, ...)\n   * @default - compile scope\n   */\n  public addModuleDependency(module: MavenModule, scope?: string): void {\n    if (module === this) {\n      throw new Error(`Module \"${this.artifactId}\" cannot depend on itself.`);\n    }\n    this.pom.addDependency(`${this.groupId}/${module.artifactId}`, scope);\n  }\n\n  private hoistDependency(spec: string): string {\n    const c = parseMavenSpec(spec);\n    if (c.version) {\n      this.parentPom.addManagedDependency(spec);\n    }\n    return `${c.groupId}/${c.artifactId}`;\n  }\n}\n"]}

package/lib/java/maven/maven-pom.d.ts

@@ -0,0 +1,143 @@
+import { Component, Project, java } from 'projen';
+/** Parsed `groupId/artifactId[@version]` spec. */
+export interface MavenCoordinates {
+    readonly groupId: string;
+    readonly artifactId: string;
+    readonly version?: string;
+}
+/**
+ * Parses `groupId/artifactId[@version]`. The version, when present, must be
+ * one exact version - a range (`[1,2)`), a semver range (`^1`, `~1.2`), or a
+ * wildcard throws, because a range resolves differently over time and makes
+ * the build non-reproducible.
+ */
+export declare function parseMavenSpec(spec: string): MavenCoordinates;
+/** Throws unless `version` is one exact version (no range, no wildcard). */
+export declare function assertExactVersion(version: string, context: string): void;
+/** Options for `MavenPom`. */
+export interface MavenPomOptions {
+    /**
+     * Path of the pom, relative to the project root.
+     * @default "pom.xml"
+     */
+    readonly filePath?: string;
+    /**
+     * `groupId`. Omit in a module pom to inherit it from `<parent>`.
+     * @default - inherited from the parent
+     */
+    readonly groupId?: string;
+    readonly artifactId: string;
+    /**
+     * `version`. Omit in a module pom to inherit it from `<parent>`.
+     * @default - inherited from the parent
+     */
+    readonly version?: string;
+    /** @default "jar" */
+    readonly packaging?: string;
+    /** @default - none */
+    readonly name?: string;
+    /** @default - none */
+    readonly description?: string;
+    /** @default - none */
+    readonly url?: string;
+    /** @default - no parent */
+    readonly parent?: java.ParentPom;
+}
+/**
+ * A `pom.xml` written by this package (rather than projen's `java.Pom`).
+ *
+ * Supports `<modules>`, `<dependencyManagement>` (including BOM imports),
+ * `<pluginManagement>`, and versionless dependencies/plugins - what a Maven
+ * reactor needs and `java.Pom` cannot express. Every version it writes is
+ * exact; a spec carrying a range throws. Plugin executions render one
+ * `<goals>` element per execution (projen's `java.Pom` repeats `<goals>`,
+ * which Maven 3.9 rejects as non-parseable).
+ *
+ * Adding the same `groupId/artifactId` twice merges: a later version
+ * replaces an earlier one only if the earlier had none (two different
+ * versions throw), and plugin options are merged - `configuration` shallowly,
+ * `executions` and `dependencies` appended.
+ */
+export declare class MavenPom extends Component {
+    /** Path of the pom, relative to the project root. */
+    readonly filePath: string;
+    readonly groupId?: string;
+    readonly artifactId: string;
+    readonly version?: string;
+    readonly name?: string;
+    readonly description?: string;
+    readonly url?: string;
+    readonly parent?: java.ParentPom;
+    /** Maven packaging (`jar`, `pom`, ...). */
+    packaging: string;
+    /**
+     * When true, the versions of `<plugins>` entries are written into
+     * `<pluginManagement>` and the `<plugins>` entries stay versionless - the
+     * shape a reactor parent wants, so modules can redeclare a plugin without
+     * repeating its version.
+     */
+    managePluginVersions: boolean;
+    private readonly properties;
+    private readonly modules;
+    private readonly boms;
+    private readonly managedDeps;
+    private readonly deps;
+    private readonly managedPlugins;
+    private readonly plugins;
+    private readonly repositories;
+    private readonly pluginRepositories;
+    constructor(project: Project, options: MavenPomOptions);
+    /** Sets a `<properties>` entry. */
+    addProperty(name: string, value: string): void;
+    /** Adds a `<module>` (a path relative to this pom's directory). */
+    addModule(path: string): void;
+    /**
+     * Imports a BOM into `<dependencyManagement>` (`type=pom`,
+     * `scope=import`). BOMs are written in the order added, before every other
+     * managed dependency.
+     *
+     * @param spec `groupId/artifactId@version` - the version is required
+     */
+    addBom(spec: string): void;
+    /** Removes a BOM import added by `addBom`, if present. */
+    removeBom(coordinates: string): void;
+    /**
+     * Pins a version in `<dependencyManagement>` without adding the
+     * dependency itself.
+     *
+     * @param spec `groupId/artifactId@version` - the version is required
+     */
+    addManagedDependency(spec: string): void;
+    /**
+     * Adds a dependency (compile scope unless `scope` is given).
+     *
+     * @param spec `groupId/artifactId[@version]` - omit the version when a BOM
+     * or the parent's `<dependencyManagement>` manages it
+     * @param scope Maven scope (`test`, `provided`, `runtime`, ...)
+     */
+    addDependency(spec: string, scope?: string): void;
+    /** Adds a `test`-scoped dependency. */
+    addTestDependency(spec: string): void;
+    /**
+     * Adds a build plugin to `<build><plugins>`.
+     *
+     * @param spec `groupId/artifactId[@version]` - omit the version when
+     * `<pluginManagement>` (here or in the parent) manages it
+     */
+    addPlugin(spec: string, options?: java.PluginOptions): void;
+    /**
+     * Adds a plugin to `<build><pluginManagement>` only: it pins the version
+     * (and optional default configuration) for this pom and its modules
+     * without running the plugin here.
+     */
+    addManagedPlugin(spec: string, options?: java.PluginOptions): void;
+    /** True if a plugin with these `groupId/artifactId` coordinates is in `<plugins>`. */
+    hasPlugin(coordinates: string): boolean;
+    /** Adds a `<repository>`. */
+    addRepository(repository: java.MavenRepository): void;
+    /** Adds a `<pluginRepository>`. */
+    addPluginRepository(repository: java.MavenRepository): void;
+    private mergeDependency;
+    private mergePlugin;
+    private synthPom;
+}