@xpertss/projen-types 0.0.13 → 0.0.15

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

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MavenPom = void 0;
+exports.parseMavenSpec = parseMavenSpec;
+exports.assertExactVersion = assertExactVersion;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const projen_1 = require("projen");
+const POM_XML_ATTRS = {
+    '@xsi:schemaLocation': 'http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd',
+    '@xmlns': 'http://maven.apache.org/POM/4.0.0',
+    '@xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
+};
+// Characters that make a version a range or a semver expression rather than
+// one exact version. Maven ranges make builds non-reproducible, so a spec
+// carrying one is rejected outright instead of being converted.
+const NON_EXACT_VERSION = /[\^~*\[\](),<>\s]|^x$|\.x(\.|$)/i;
+/**
+ * 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.
+ */
+function parseMavenSpec(spec) {
+    const at = spec.indexOf('@');
+    const name = at === -1 ? spec : spec.slice(0, at);
+    const version = at === -1 ? undefined : spec.slice(at + 1);
+    const parts = name.split('/');
+    if (parts.length !== 2 || !parts[0] || !parts[1]) {
+        throw new Error(`Invalid Maven spec "${spec}". Format is "<groupId>/<artifactId>[@<version>]", e.g. "org.yaml/snakeyaml@2.4".`);
+    }
+    if (version !== undefined) {
+        assertExactVersion(version, spec);
+    }
+    return { groupId: parts[0], artifactId: parts[1], version };
+}
+/** Throws unless `version` is one exact version (no range, no wildcard). */
+function assertExactVersion(version, context) {
+    if (!version || NON_EXACT_VERSION.test(version)) {
+        throw new Error(`"${context}" uses version "${version}", which is not an exact version. Generated poms never contain version ranges: pin one exact version (e.g. "1.2.3"), or omit the version when a BOM manages it.`);
+    }
+}
+function key(c) {
+    return `${c.groupId}/${c.artifactId}`;
+}
+/**
+ * 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.
+ */
+class MavenPom extends projen_1.Component {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@xpertss/projen-types.MavenPom", version: "0.0.15" };
+    /** Path of the pom, relative to the project root. */
+    filePath;
+    groupId;
+    artifactId;
+    version;
+    name;
+    description;
+    url;
+    parent;
+    /** Maven packaging (`jar`, `pom`, ...). */
+    packaging;
+    /**
+     * 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 = false;
+    properties = {};
+    modules = [];
+    boms = [];
+    managedDeps = new Map();
+    deps = new Map();
+    managedPlugins = new Map();
+    plugins = new Map();
+    repositories = [];
+    pluginRepositories = [];
+    constructor(project, options) {
+        super(project);
+        this.filePath = options.filePath ?? 'pom.xml';
+        this.groupId = options.groupId;
+        this.artifactId = options.artifactId;
+        this.version = options.version;
+        this.packaging = options.packaging ?? 'jar';
+        this.name = options.name;
+        this.description = options.description;
+        this.url = options.url;
+        this.parent = options.parent;
+        if (this.version !== undefined) {
+            assertExactVersion(this.version, `${this.artifactId} version`);
+        }
+        new projen_1.XmlFile(project, this.filePath, { obj: () => this.synthPom() });
+    }
+    /** Sets a `<properties>` entry. */
+    addProperty(name, value) {
+        this.properties[name] = value;
+    }
+    /** Adds a `<module>` (a path relative to this pom's directory). */
+    addModule(path) {
+        if (!this.modules.includes(path)) {
+            this.modules.push(path);
+        }
+    }
+    /**
+     * 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) {
+        const coords = parseMavenSpec(spec);
+        if (!coords.version) {
+            throw new Error(`BOM "${spec}" needs a version: a BOM import cannot be versionless.`);
+        }
+        const existing = this.boms.findIndex((b) => key(b) === key(coords));
+        if (existing !== -1) {
+            this.boms[existing] = coords;
+        }
+        else {
+            this.boms.push(coords);
+        }
+    }
+    /** Removes a BOM import added by `addBom`, if present. */
+    removeBom(coordinates) {
+        const index = this.boms.findIndex((b) => key(b) === coordinates);
+        if (index !== -1) {
+            this.boms.splice(index, 1);
+        }
+    }
+    /**
+     * Pins a version in `<dependencyManagement>` without adding the
+     * dependency itself.
+     *
+     * @param spec `groupId/artifactId@version` - the version is required
+     */
+    addManagedDependency(spec) {
+        const coords = parseMavenSpec(spec);
+        if (!coords.version) {
+            throw new Error(`Managed dependency "${spec}" needs a version.`);
+        }
+        this.mergeDependency(this.managedDeps, { coords }, 'dependencyManagement');
+    }
+    /**
+     * 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, scope) {
+        this.mergeDependency(this.deps, { coords: parseMavenSpec(spec), scope }, 'dependencies');
+    }
+    /** Adds a `test`-scoped dependency. */
+    addTestDependency(spec) {
+        this.addDependency(spec, 'test');
+    }
+    /**
+     * 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, options = {}) {
+        this.mergePlugin(this.plugins, parseMavenSpec(spec), options);
+    }
+    /**
+     * 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, options = {}) {
+        this.mergePlugin(this.managedPlugins, parseMavenSpec(spec), options);
+    }
+    /** True if a plugin with these `groupId/artifactId` coordinates is in `<plugins>`. */
+    hasPlugin(coordinates) {
+        return this.plugins.has(coordinates);
+    }
+    /** Adds a `<repository>`. */
+    addRepository(repository) {
+        this.repositories.push(repository);
+    }
+    /** Adds a `<pluginRepository>`. */
+    addPluginRepository(repository) {
+        this.pluginRepositories.push(repository);
+    }
+    mergeDependency(target, entry, section) {
+        const k = key(entry.coords);
+        const existing = target.get(k);
+        if (!existing) {
+            target.set(k, entry);
+            return;
+        }
+        const version = mergeVersion(existing.coords, entry.coords, section);
+        target.set(k, {
+            coords: { ...entry.coords, version },
+            scope: entry.scope ?? existing.scope,
+            type: entry.type ?? existing.type,
+        });
+    }
+    mergePlugin(target, coords, options) {
+        const k = key(coords);
+        const existing = target.get(k);
+        if (!existing) {
+            target.set(k, { coords, options });
+            return;
+        }
+        const version = mergeVersion(existing.coords, coords, 'plugins');
+        const executions = [...(existing.options.executions ?? [])];
+        for (const e of options.executions ?? []) {
+            const i = executions.findIndex((x) => x.id === e.id);
+            if (i === -1) {
+                executions.push(e);
+            }
+            else {
+                executions[i] = e;
+            }
+        }
+        target.set(k, {
+            coords: { ...coords, version },
+            options: {
+                configuration: existing.options.configuration || options.configuration
+                    ? { ...existing.options.configuration, ...options.configuration }
+                    : undefined,
+                executions: executions.length ? executions : undefined,
+                dependencies: [
+                    ...(existing.options.dependencies ?? []),
+                    ...(options.dependencies ?? []),
+                ],
+            },
+        });
+    }
+    synthPom() {
+        const managedPlugins = new Map(this.managedPlugins);
+        const plugins = [];
+        for (const p of this.plugins.values()) {
+            if (this.managePluginVersions && p.coords.version) {
+                const k = key(p.coords);
+                if (!managedPlugins.has(k)) {
+                    managedPlugins.set(k, { coords: p.coords, options: {} });
+                }
+                plugins.push(renderPlugin({ ...p.coords, version: undefined }, p.options));
+            }
+            else {
+                plugins.push(renderPlugin(p.coords, p.options));
+            }
+        }
+        const managed = [
+            ...this.boms.map((b) => ({ ...renderCoords(b), type: 'pom', scope: 'import' })),
+            ...[...this.managedDeps.values()].map(renderDependency),
+        ];
+        const pluginManagement = [...managedPlugins.values()].map((p) => renderPlugin(p.coords, p.options));
+        // JSON round-trip drops every `undefined` field, so absent sections are
+        // omitted rather than written as empty elements.
+        return JSON.parse(JSON.stringify({
+            project: {
+                ...POM_XML_ATTRS,
+                modelVersion: '4.0.0',
+                parent: this.parent,
+                groupId: this.groupId,
+                artifactId: this.artifactId,
+                version: this.version,
+                // `jar` is Maven's default and is left implicit.
+                packaging: this.packaging === 'jar' ? undefined : this.packaging,
+                name: this.name,
+                description: this.description,
+                url: this.url,
+                modules: this.modules.length ? { module: this.modules } : undefined,
+                properties: Object.keys(this.properties).length ? this.properties : undefined,
+                repositories: this.repositories.length
+                    ? { repository: this.repositories }
+                    : undefined,
+                pluginRepositories: this.pluginRepositories.length
+                    ? { pluginRepository: this.pluginRepositories }
+                    : undefined,
+                dependencyManagement: managed.length
+                    ? { dependencies: { dependency: managed } }
+                    : undefined,
+                dependencies: this.deps.size
+                    ? { dependency: [...this.deps.values()].map(renderDependency) }
+                    : undefined,
+                build: plugins.length || pluginManagement.length
+                    ? {
+                        pluginManagement: pluginManagement.length
+                            ? { plugins: { plugin: pluginManagement } }
+                            : undefined,
+                        plugins: plugins.length ? { plugin: plugins } : undefined,
+                    }
+                    : undefined,
+            },
+        }));
+    }
+}
+exports.MavenPom = MavenPom;
+function mergeVersion(existing, added, section) {
+    if (existing.version && added.version && existing.version !== added.version) {
+        throw new Error(`${key(added)} is pinned at two different versions in ${section} (${existing.version} and ${added.version}). Pin it once.`);
+    }
+    return added.version ?? existing.version;
+}
+function renderCoords(c) {
+    return { groupId: c.groupId, artifactId: c.artifactId, version: c.version };
+}
+function renderDependency(d) {
+    return { ...renderCoords(d.coords), type: d.type, scope: d.scope };
+}
+function renderPlugin(c, options) {
+    const deps = (options.dependencies ?? []).map((d) => renderCoords(parseMavenSpec(d)));
+    return {
+        ...renderCoords(c),
+        configuration: options.configuration,
+        dependencies: deps.length ? { dependency: deps } : undefined,
+        executions: options.executions?.length
+            ? {
+                execution: options.executions.map((e) => ({
+                    id: e.id,
+                    phase: e.phase,
+                    // One <goals> holding every <goal> - not one <goals> per goal.
+                    goals: { goal: e.goals },
+                    configuration: e.configuration,
+                })),
+            }
+            : undefined,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"maven-pom.js","sourceRoot":"","sources":["../../../src/java/maven/maven-pom.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Project, XmlFile, java } from 'projen';\n\nconst POM_XML_ATTRS = {\n  '@xsi:schemaLocation':\n    'http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd',\n  '@xmlns': 'http://maven.apache.org/POM/4.0.0',\n  '@xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',\n};\n\n// Characters that make a version a range or a semver expression rather than\n// one exact version. Maven ranges make builds non-reproducible, so a spec\n// carrying one is rejected outright instead of being converted.\nconst NON_EXACT_VERSION = /[\\^~*\\[\\](),<>\\s]|^x$|\\.x(\\.|$)/i;\n\n/** Parsed `groupId/artifactId[@version]` spec. */\nexport interface MavenCoordinates {\n  readonly groupId: string;\n  readonly artifactId: string;\n  readonly version?: string;\n}\n\n/**\n * Parses `groupId/artifactId[@version]`. The version, when present, must be\n * one exact version - a range (`[1,2)`), a semver range (`^1`, `~1.2`), or a\n * wildcard throws, because a range resolves differently over time and makes\n * the build non-reproducible.\n */\nexport function parseMavenSpec(spec: string): MavenCoordinates {\n  const at = spec.indexOf('@');\n  const name = at === -1 ? spec : spec.slice(0, at);\n  const version = at === -1 ? undefined : spec.slice(at + 1);\n  const parts = name.split('/');\n  if (parts.length !== 2 || !parts[0] || !parts[1]) {\n    throw new Error(\n      `Invalid Maven spec \"${spec}\". Format is \"<groupId>/<artifactId>[@<version>]\", e.g. \"org.yaml/snakeyaml@2.4\".`,\n    );\n  }\n  if (version !== undefined) {\n    assertExactVersion(version, spec);\n  }\n  return { groupId: parts[0], artifactId: parts[1], version };\n}\n\n/** Throws unless `version` is one exact version (no range, no wildcard). */\nexport function assertExactVersion(version: string, context: string): void {\n  if (!version || NON_EXACT_VERSION.test(version)) {\n    throw new Error(\n      `\"${context}\" uses version \"${version}\", which is not an exact version. Generated poms never contain version ranges: pin one exact version (e.g. \"1.2.3\"), or omit the version when a BOM manages it.`,\n    );\n  }\n}\n\n/** Options for `MavenPom`. */\nexport interface MavenPomOptions {\n  /**\n   * Path of the pom, relative to the project root.\n   * @default \"pom.xml\"\n   */\n  readonly filePath?: string;\n\n  /**\n   * `groupId`. Omit in a module pom to inherit it from `<parent>`.\n   * @default - inherited from the parent\n   */\n  readonly groupId?: string;\n\n  readonly artifactId: string;\n\n  /**\n   * `version`. Omit in a module pom to inherit it from `<parent>`.\n   * @default - inherited from the parent\n   */\n  readonly version?: string;\n\n  /** @default \"jar\" */\n  readonly packaging?: string;\n\n  /** @default - none */\n  readonly name?: string;\n\n  /** @default - none */\n  readonly description?: string;\n\n  /** @default - none */\n  readonly url?: string;\n\n  /** @default - no parent */\n  readonly parent?: java.ParentPom;\n}\n\ninterface DependencyEntry {\n  readonly coords: MavenCoordinates;\n  readonly scope?: string;\n  readonly type?: string;\n}\n\ninterface PluginEntry {\n  readonly coords: MavenCoordinates;\n  readonly options: java.PluginOptions;\n}\n\nfunction key(c: MavenCoordinates): string {\n  return `${c.groupId}/${c.artifactId}`;\n}\n\n/**\n * A `pom.xml` written by this package (rather than projen's `java.Pom`).\n *\n * Supports `<modules>`, `<dependencyManagement>` (including BOM imports),\n * `<pluginManagement>`, and versionless dependencies/plugins - what a Maven\n * reactor needs and `java.Pom` cannot express. Every version it writes is\n * exact; a spec carrying a range throws. Plugin executions render one\n * `<goals>` element per execution (projen's `java.Pom` repeats `<goals>`,\n * which Maven 3.9 rejects as non-parseable).\n *\n * Adding the same `groupId/artifactId` twice merges: a later version\n * replaces an earlier one only if the earlier had none (two different\n * versions throw), and plugin options are merged - `configuration` shallowly,\n * `executions` and `dependencies` appended.\n */\nexport class MavenPom extends Component {\n  /** Path of the pom, relative to the project root. */\n  public readonly filePath: string;\n  public readonly groupId?: string;\n  public readonly artifactId: string;\n  public readonly version?: string;\n  public readonly name?: string;\n  public readonly description?: string;\n  public readonly url?: string;\n  public readonly parent?: java.ParentPom;\n\n  /** Maven packaging (`jar`, `pom`, ...). */\n  public packaging: string;\n\n  /**\n   * When true, the versions of `<plugins>` entries are written into\n   * `<pluginManagement>` and the `<plugins>` entries stay versionless - the\n   * shape a reactor parent wants, so modules can redeclare a plugin without\n   * repeating its version.\n   */\n  public managePluginVersions = false;\n\n  private readonly properties: Record<string, string> = {};\n  private readonly modules: string[] = [];\n  private readonly boms: MavenCoordinates[] = [];\n  private readonly managedDeps = new Map<string, DependencyEntry>();\n  private readonly deps = new Map<string, DependencyEntry>();\n  private readonly managedPlugins = new Map<string, PluginEntry>();\n  private readonly plugins = new Map<string, PluginEntry>();\n  private readonly repositories: java.MavenRepository[] = [];\n  private readonly pluginRepositories: java.MavenRepository[] = [];\n\n  constructor(project: Project, options: MavenPomOptions) {\n    super(project);\n    this.filePath = options.filePath ?? 'pom.xml';\n    this.groupId = options.groupId;\n    this.artifactId = options.artifactId;\n    this.version = options.version;\n    this.packaging = options.packaging ?? 'jar';\n    this.name = options.name;\n    this.description = options.description;\n    this.url = options.url;\n    this.parent = options.parent;\n    if (this.version !== undefined) {\n      assertExactVersion(this.version, `${this.artifactId} version`);\n    }\n\n    new XmlFile(project, this.filePath, { obj: () => this.synthPom() });\n  }\n\n  /** Sets a `<properties>` entry. */\n  public addProperty(name: string, value: string): void {\n    this.properties[name] = value;\n  }\n\n  /** Adds a `<module>` (a path relative to this pom's directory). */\n  public addModule(path: string): void {\n    if (!this.modules.includes(path)) {\n      this.modules.push(path);\n    }\n  }\n\n  /**\n   * Imports a BOM into `<dependencyManagement>` (`type=pom`,\n   * `scope=import`). BOMs are written in the order added, before every other\n   * managed dependency.\n   *\n   * @param spec `groupId/artifactId@version` - the version is required\n   */\n  public addBom(spec: string): void {\n    const coords = parseMavenSpec(spec);\n    if (!coords.version) {\n      throw new Error(`BOM \"${spec}\" needs a version: a BOM import cannot be versionless.`);\n    }\n    const existing = this.boms.findIndex((b) => key(b) === key(coords));\n    if (existing !== -1) {\n      this.boms[existing] = coords;\n    } else {\n      this.boms.push(coords);\n    }\n  }\n\n  /** Removes a BOM import added by `addBom`, if present. */\n  public removeBom(coordinates: string): void {\n    const index = this.boms.findIndex((b) => key(b) === coordinates);\n    if (index !== -1) {\n      this.boms.splice(index, 1);\n    }\n  }\n\n  /**\n   * Pins a version in `<dependencyManagement>` without adding the\n   * dependency itself.\n   *\n   * @param spec `groupId/artifactId@version` - the version is required\n   */\n  public addManagedDependency(spec: string): void {\n    const coords = parseMavenSpec(spec);\n    if (!coords.version) {\n      throw new Error(`Managed dependency \"${spec}\" needs a version.`);\n    }\n    this.mergeDependency(this.managedDeps, { coords }, 'dependencyManagement');\n  }\n\n  /**\n   * Adds a dependency (compile scope unless `scope` is given).\n   *\n   * @param spec `groupId/artifactId[@version]` - omit the version when a BOM\n   * or the parent's `<dependencyManagement>` manages it\n   * @param scope Maven scope (`test`, `provided`, `runtime`, ...)\n   */\n  public addDependency(spec: string, scope?: string): void {\n    this.mergeDependency(\n      this.deps,\n      { coords: parseMavenSpec(spec), scope },\n      'dependencies',\n    );\n  }\n\n  /** Adds a `test`-scoped dependency. */\n  public addTestDependency(spec: string): void {\n    this.addDependency(spec, 'test');\n  }\n\n  /**\n   * Adds a build plugin to `<build><plugins>`.\n   *\n   * @param spec `groupId/artifactId[@version]` - omit the version when\n   * `<pluginManagement>` (here or in the parent) manages it\n   */\n  public addPlugin(spec: string, options: java.PluginOptions = {}): void {\n    this.mergePlugin(this.plugins, parseMavenSpec(spec), options);\n  }\n\n  /**\n   * Adds a plugin to `<build><pluginManagement>` only: it pins the version\n   * (and optional default configuration) for this pom and its modules\n   * without running the plugin here.\n   */\n  public addManagedPlugin(spec: string, options: java.PluginOptions = {}): void {\n    this.mergePlugin(this.managedPlugins, parseMavenSpec(spec), options);\n  }\n\n  /** True if a plugin with these `groupId/artifactId` coordinates is in `<plugins>`. */\n  public hasPlugin(coordinates: string): boolean {\n    return this.plugins.has(coordinates);\n  }\n\n  /** Adds a `<repository>`. */\n  public addRepository(repository: java.MavenRepository): void {\n    this.repositories.push(repository);\n  }\n\n  /** Adds a `<pluginRepository>`. */\n  public addPluginRepository(repository: java.MavenRepository): void {\n    this.pluginRepositories.push(repository);\n  }\n\n  private mergeDependency(\n    target: Map<string, DependencyEntry>,\n    entry: DependencyEntry,\n    section: string,\n  ): void {\n    const k = key(entry.coords);\n    const existing = target.get(k);\n    if (!existing) {\n      target.set(k, entry);\n      return;\n    }\n    const version = mergeVersion(existing.coords, entry.coords, section);\n    target.set(k, {\n      coords: { ...entry.coords, version },\n      scope: entry.scope ?? existing.scope,\n      type: entry.type ?? existing.type,\n    });\n  }\n\n  private mergePlugin(\n    target: Map<string, PluginEntry>,\n    coords: MavenCoordinates,\n    options: java.PluginOptions,\n  ): void {\n    const k = key(coords);\n    const existing = target.get(k);\n    if (!existing) {\n      target.set(k, { coords, options });\n      return;\n    }\n    const version = mergeVersion(existing.coords, coords, 'plugins');\n    const executions = [...(existing.options.executions ?? [])];\n    for (const e of options.executions ?? []) {\n      const i = executions.findIndex((x) => x.id === e.id);\n      if (i === -1) {\n        executions.push(e);\n      } else {\n        executions[i] = e;\n      }\n    }\n    target.set(k, {\n      coords: { ...coords, version },\n      options: {\n        configuration:\n          existing.options.configuration || options.configuration\n            ? { ...existing.options.configuration, ...options.configuration }\n            : undefined,\n        executions: executions.length ? executions : undefined,\n        dependencies: [\n          ...(existing.options.dependencies ?? []),\n          ...(options.dependencies ?? []),\n        ],\n      },\n    });\n  }\n\n  private synthPom(): any {\n    const managedPlugins = new Map(this.managedPlugins);\n    const plugins: any[] = [];\n    for (const p of this.plugins.values()) {\n      if (this.managePluginVersions && p.coords.version) {\n        const k = key(p.coords);\n        if (!managedPlugins.has(k)) {\n          managedPlugins.set(k, { coords: p.coords, options: {} });\n        }\n        plugins.push(renderPlugin({ ...p.coords, version: undefined }, p.options));\n      } else {\n        plugins.push(renderPlugin(p.coords, p.options));\n      }\n    }\n\n    const managed = [\n      ...this.boms.map((b) => ({ ...renderCoords(b), type: 'pom', scope: 'import' })),\n      ...[...this.managedDeps.values()].map(renderDependency),\n    ];\n\n    const pluginManagement = [...managedPlugins.values()].map((p) =>\n      renderPlugin(p.coords, p.options),\n    );\n\n    // JSON round-trip drops every `undefined` field, so absent sections are\n    // omitted rather than written as empty elements.\n    return JSON.parse(JSON.stringify({\n      project: {\n        ...POM_XML_ATTRS,\n        modelVersion: '4.0.0',\n        parent: this.parent,\n        groupId: this.groupId,\n        artifactId: this.artifactId,\n        version: this.version,\n        // `jar` is Maven's default and is left implicit.\n        packaging: this.packaging === 'jar' ? undefined : this.packaging,\n        name: this.name,\n        description: this.description,\n        url: this.url,\n        modules: this.modules.length ? { module: this.modules } : undefined,\n        properties: Object.keys(this.properties).length ? this.properties : undefined,\n        repositories: this.repositories.length\n          ? { repository: this.repositories }\n          : undefined,\n        pluginRepositories: this.pluginRepositories.length\n          ? { pluginRepository: this.pluginRepositories }\n          : undefined,\n        dependencyManagement: managed.length\n          ? { dependencies: { dependency: managed } }\n          : undefined,\n        dependencies: this.deps.size\n          ? { dependency: [...this.deps.values()].map(renderDependency) }\n          : undefined,\n        build:\n          plugins.length || pluginManagement.length\n            ? {\n              pluginManagement: pluginManagement.length\n                ? { plugins: { plugin: pluginManagement } }\n                : undefined,\n              plugins: plugins.length ? { plugin: plugins } : undefined,\n            }\n            : undefined,\n      },\n    }));\n  }\n}\n\nfunction mergeVersion(\n  existing: MavenCoordinates,\n  added: MavenCoordinates,\n  section: string,\n): string | undefined {\n  if (existing.version && added.version && existing.version !== added.version) {\n    throw new Error(\n      `${key(added)} is pinned at two different versions in ${section} (${existing.version} and ${added.version}). Pin it once.`,\n    );\n  }\n  return added.version ?? existing.version;\n}\n\nfunction renderCoords(c: MavenCoordinates): any {\n  return { groupId: c.groupId, artifactId: c.artifactId, version: c.version };\n}\n\nfunction renderDependency(d: DependencyEntry): any {\n  return { ...renderCoords(d.coords), type: d.type, scope: d.scope };\n}\n\nfunction renderPlugin(c: MavenCoordinates, options: java.PluginOptions): any {\n  const deps = (options.dependencies ?? []).map((d) => renderCoords(parseMavenSpec(d)));\n  return {\n    ...renderCoords(c),\n    configuration: options.configuration,\n    dependencies: deps.length ? { dependency: deps } : undefined,\n    executions: options.executions?.length\n      ? {\n        execution: options.executions.map((e) => ({\n          id: e.id,\n          phase: e.phase,\n          // One <goals> holding every <goal> - not one <goals> per goal.\n          goals: { goal: e.goals },\n          configuration: e.configuration,\n        })),\n      }\n      : undefined,\n  };\n}\n"]}

package/lib/java/options.d.ts

@@ -5,10 +5,122 @@ export interface CommonJavaOptions {
     readonly artifactId: string;
     /** @default "0.1.0" */
     readonly version?: string;
+    /** Project description, written to the root pom. @default - none */
+    readonly description?: string;
+    /** Project URL, written to the root pom. @default - none */
+    readonly url?: string;
     /** SonarCloud project key. If unset, the sonar scan step is skipped. */
     readonly sonarProjectKey?: string;
     /** @default "PROJEN_GITHUB_TOKEN" */
     readonly gheTokenSecret?: string;
+    /**
+     * Java line the build targets: `1.8` (alias `8`), `17`, `21`, or `25`.
+     *
+     * Drives every Java-dependent part of the generated build: the compiler
+     * level (`maven.compiler.release`, or `source`/`target` for 1.8, which has
+     * no `--release`), the enforcer's `requireJavaVersion` rule, the JUnit line,
+     * the default Spring Boot line, and the JDK CI installs. Any other value
+     * fails at synth and lists the supported lines.
+     *
+     * @default "21"
+     */
+    readonly javaVersion?: string;
+    /**
+     * `actions/setup-java` distribution CI installs the JDK from.
+     * @default "temurin"
+     */
+    readonly javaDistribution?: string;
+    /**
+     * Maven packaging of the root pom while the project has no modules. Once
+     * `addModule()` is called the root pom is always `pom`-packaged (and
+     * setting anything other than `pom` here is a synth error).
+     *
+     * @default "jar"
+     */
+    readonly packaging?: string;
+    /**
+     * Write a starter `Main` class and test under the `groupId` package, if
+     * `src/` does not exist yet. Never written for a multi-module project.
+     *
+     * @default false
+     */
+    readonly sample?: boolean;
+    /**
+     * Add `maven-enforcer-plugin`, which fails the build up front when the JDK
+     * or Maven running it is older than the project needs (rather than later,
+     * with confusing compiler errors). Its Java rule always follows
+     * `javaVersion`.
+     *
+     * @default true
+     */
+    readonly enforcer?: boolean;
+    /**
+     * Lowest Maven version the enforcer accepts (`requireMavenVersion
+     * [<this>,)`). Ignored when `enforcer` is false.
+     *
+     * @default "3.9"
+     */
+    readonly minMavenVersion?: string;
+    /**
+     * Overrides for the plugin/BOM versions this package pins by default,
+     * keyed by `groupId/artifactId`, e.g.
+     * `{ 'org.apache.maven.plugins/maven-surefire-plugin': '3.5.6' }`. Values
+     * must be exact versions.
+     *
+     * @default - the defaults for `javaVersion`
+     */
+    readonly pluginVersions?: {
+        [coordinates: string]: string;
+    };
+    /**
+     * Write a `LICENSE` file.
+     * @default true
+     */
+    readonly licensed?: boolean;
+    /**
+     * SPDX identifier for the generated `LICENSE`.
+     * @default "MIT"
+     */
+    readonly license?: string;
+    /**
+     * Copyright owner named in the `LICENSE`.
+     * @default "xpertss" (same as `GitHubActionProject`)
+     */
+    readonly copyrightOwner?: string;
+    /**
+     * Copyright period named in the `LICENSE`.
+     * @default - the current year
+     */
+    readonly copyrightPeriod?: string;
+    /**
+     * Write a projen-managed `.editorconfig`.
+     * @default true
+     */
+    readonly editorconfig?: boolean;
+    /**
+     * Generate the nightly `upgrade.yml` workflow, which reports available
+     * dependency and plugin updates in the job summary (it never edits files -
+     * versions are changed in `.projenrc.ts`).
+     *
+     * @default true
+     */
+    readonly upgradeWorkflow?: boolean;
+}
+/** Options for `JavaMavenProject`. */
+export interface JavaMavenProjectOptions extends CommonJavaOptions {
+}
+/** Options for `JavaSpringBootProject`. */
+export interface JavaSpringBootProjectOptions extends CommonJavaOptions {
+    /**
+     * Spring Boot version: imports `spring-boot-dependencies` as the first
+     * BOM, and versions `spring-boot-maven-plugin`. Must be an exact version.
+     * Spring Boot 3 and later need Java 17+, so with `javaVersion: '1.8'` only
+     * a 2.x version is accepted.
+     *
+     * @default - the newest release of the line supporting `javaVersion`
+     * (2.7.x for 1.8, otherwise the current major)
+     */
+    readonly springBootVersion?: string;
 }
 export interface JavaLibraryProjectOptions extends CommonJavaOptions {
     /** Use Maven Central's OIDC trusted-publishing flow instead of secret-based GPG signing. */
@@ -26,7 +138,7 @@ export interface CdkDeployHookOptions {
      */
     readonly targetRepo?: string;
 }
-export interface JavaServiceProjectOptions extends CommonJavaOptions {
+export interface JavaServiceProjectOptions extends JavaSpringBootProjectOptions {
     /** @default "docker.io" */
     readonly dockerRegistry?: string;
     /** @default true */
@@ -63,3 +175,18 @@ export interface JavaAppProjectOptions extends CommonJavaOptions {
     /** @default "https://maven.pkg.github.com/OWNER/REPO" (derived from the repository URL) */
     readonly ghPackagesRegistry?: string;
 }
+/** Options for `JavaMavenProject.addModule()`. */
+export interface MavenModuleOptions {
+    /**
+     * Module directory, relative to the repo root (may be nested, e.g.
+     * `tools/stub-model`). Its `pom.xml` is generated there.
+     */
+    readonly dir: string;
+    readonly artifactId: string;
+    /** @default - the artifactId */
+    readonly name?: string;
+    /** @default - none */
+    readonly description?: string;
+    /** @default "jar" */
+    readonly packaging?: string;
+}

package/lib/java/options.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"options.js","sourceRoot":"","sources":["../../src/java/options.ts"],"names":[],"mappings":"","sourcesContent":["import { EnvironmentOptions } from '../common/environment-options';\n\nexport interface CommonJavaOptions {\n  readonly name: string;\n  readonly groupId: string;\n  readonly artifactId: string;\n\n  /** @default \"0.1.0\" */\n  readonly version?: string;\n\n  /** Project description, written to the root pom. @default - none */\n  readonly description?: string;\n\n  /** Project URL, written to the root pom. @default - none */\n  readonly url?: string;\n\n  /** SonarCloud project key. If unset, the sonar scan step is skipped. */\n  readonly sonarProjectKey?: string;\n\n  /** @default \"PROJEN_GITHUB_TOKEN\" */\n  readonly gheTokenSecret?: string;\n\n  /**\n   * Java line the build targets: `1.8` (alias `8`), `17`, `21`, or `25`.\n   *\n   * Drives every Java-dependent part of the generated build: the compiler\n   * level (`maven.compiler.release`, or `source`/`target` for 1.8, which has\n   * no `--release`), the enforcer's `requireJavaVersion` rule, the JUnit line,\n   * the default Spring Boot line, and the JDK CI installs. Any other value\n   * fails at synth and lists the supported lines.\n   *\n   * @default \"21\"\n   */\n  readonly javaVersion?: string;\n\n  /**\n   * `actions/setup-java` distribution CI installs the JDK from.\n   * @default \"temurin\"\n   */\n  readonly javaDistribution?: string;\n\n  /**\n   * Maven packaging of the root pom while the project has no modules. Once\n   * `addModule()` is called the root pom is always `pom`-packaged (and\n   * setting anything other than `pom` here is a synth error).\n   *\n   * @default \"jar\"\n   */\n  readonly packaging?: string;\n\n  /**\n   * Write a starter `Main` class and test under the `groupId` package, if\n   * `src/` does not exist yet. Never written for a multi-module project.\n   *\n   * @default false\n   */\n  readonly sample?: boolean;\n\n  /**\n   * Add `maven-enforcer-plugin`, which fails the build up front when the JDK\n   * or Maven running it is older than the project needs (rather than later,\n   * with confusing compiler errors). Its Java rule always follows\n   * `javaVersion`.\n   *\n   * @default true\n   */\n  readonly enforcer?: boolean;\n\n  /**\n   * Lowest Maven version the enforcer accepts (`requireMavenVersion\n   * [<this>,)`). Ignored when `enforcer` is false.\n   *\n   * @default \"3.9\"\n   */\n  readonly minMavenVersion?: string;\n\n  /**\n   * Overrides for the plugin/BOM versions this package pins by default,\n   * keyed by `groupId/artifactId`, e.g.\n   * `{ 'org.apache.maven.plugins/maven-surefire-plugin': '3.5.6' }`. Values\n   * must be exact versions.\n   *\n   * @default - the defaults for `javaVersion`\n   */\n  readonly pluginVersions?: { [coordinates: string]: string };\n\n  /**\n   * Write a `LICENSE` file.\n   * @default true\n   */\n  readonly licensed?: boolean;\n\n  /**\n   * SPDX identifier for the generated `LICENSE`.\n   * @default \"MIT\"\n   */\n  readonly license?: string;\n\n  /**\n   * Copyright owner named in the `LICENSE`.\n   * @default \"xpertss\" (same as `GitHubActionProject`)\n   */\n  readonly copyrightOwner?: string;\n\n  /**\n   * Copyright period named in the `LICENSE`.\n   * @default - the current year\n   */\n  readonly copyrightPeriod?: string;\n\n  /**\n   * Write a projen-managed `.editorconfig`.\n   * @default true\n   */\n  readonly editorconfig?: boolean;\n\n  /**\n   * Generate the nightly `upgrade.yml` workflow, which reports available\n   * dependency and plugin updates in the job summary (it never edits files -\n   * versions are changed in `.projenrc.ts`).\n   *\n   * @default true\n   */\n  readonly upgradeWorkflow?: boolean;\n}\n\n/** Options for `JavaMavenProject`. */\nexport interface JavaMavenProjectOptions extends CommonJavaOptions {}\n\n/** Options for `JavaSpringBootProject`. */\nexport interface JavaSpringBootProjectOptions extends CommonJavaOptions {\n  /**\n   * Spring Boot version: imports `spring-boot-dependencies` as the first\n   * BOM, and versions `spring-boot-maven-plugin`. Must be an exact version.\n   * Spring Boot 3 and later need Java 17+, so with `javaVersion: '1.8'` only\n   * a 2.x version is accepted.\n   *\n   * @default - the newest release of the line supporting `javaVersion`\n   * (2.7.x for 1.8, otherwise the current major)\n   */\n  readonly springBootVersion?: string;\n}\n\nexport interface JavaLibraryProjectOptions extends CommonJavaOptions {\n  /** Use Maven Central's OIDC trusted-publishing flow instead of secret-based GPG signing. */\n  readonly mavenCentralOidc?: boolean;\n\n  /** @default true */\n  readonly publishCodeIndex?: boolean;\n}\n\nexport interface CdkDeployHookOptions {\n  /**\n   * The companion CDK infra/app repo (owner/repo) that owns the actual\n   * infrastructure.\n   *\n   * @default - the workflow is still generated, but its only step fails with\n   * instructions (see `CdkDeployHook`)\n   */\n  readonly targetRepo?: string;\n}\n\nexport interface JavaServiceProjectOptions extends JavaSpringBootProjectOptions {\n  /** @default \"docker.io\" */\n  readonly dockerRegistry?: string;\n\n  /** @default true */\n  readonly useFlyway?: boolean;\n\n  /**\n   * The companion CDK infra/app repo (`owner/repo`) whose `deploy.yml` the\n   * `deploy-cdk` workflow dispatches.\n   *\n   * A plain string rather than a nested struct so that\n   * `projen new --from @xpertss/projen-types java_service` can pass it\n   * (`--cdk-deploy-target-repo owner/repo`): projen's CLI can only render\n   * options whose type is a string/number/boolean/array/enum, so a\n   * struct-typed option is invisible to it.\n   *\n   * @default - `deploy-cdk.yml` is generated with a single failing step that\n   * tells you to set this\n   */\n  readonly cdkDeployTargetRepo?: string;\n\n  /**\n   * Whether to generate the `deploy-cdk` workflow at all.\n   *\n   * @default true\n   */\n  readonly cdkDeployHook?: boolean;\n\n  /**\n   * Deploy targets to offer on the `CdkDeployHook`'s manual-dispatch\n   * workflow, when the hook is enabled.\n   *\n   * @default [\"prod\"]\n   */\n  readonly environments?: (string | EnvironmentOptions)[];\n}\n\nexport interface JavaAppProjectOptions extends CommonJavaOptions {\n  /** @default \"https://maven.pkg.github.com/OWNER/REPO\" (derived from the repository URL) */\n  readonly ghPackagesRegistry?: string;\n}\n\n/** Options for `JavaMavenProject.addModule()`. */\nexport interface MavenModuleOptions {\n  /**\n   * Module directory, relative to the repo root (may be nested, e.g.\n   * `tools/stub-model`). Its `pom.xml` is generated there.\n   */\n  readonly dir: string;\n\n  readonly artifactId: string;\n\n  /** @default - the artifactId */\n  readonly name?: string;\n\n  /** @default - none */\n  readonly description?: string;\n\n  /** @default \"jar\" */\n  readonly packaging?: string;\n}\n"]}

package/package.json

@@ -82,7 +82,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.13",
+  "version": "0.0.15",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [

package/lib/common/upgrade-workflow.d.ts

@@ -1,18 +0,0 @@
-import { Component, Task, github } from 'projen';
-/**
- * Nightly cron workflow that opens a PR with dependency upgrades. Used by
- * non-Node project types (Java); TypeScript/CDK project types instead get
- * this for free from projen's built-in `depsUpgrade`.
- */
-export interface UpgradeWorkflowOptions {
-    /** The task that performs the upgrade (e.g. `mvn versions:use-latest-releases`). */
-    readonly task: Task;
-    /** @default "upgrade" */
-    readonly workflowName?: string;
-    /** @default NIGHTLY_UPGRADE_SCHEDULE (03:00 UTC) */
-    readonly schedule?: string;
-}
-export declare class UpgradeWorkflow extends Component {
-    readonly workflow: github.TaskWorkflow;
-    constructor(scope: github.GitHubProject, options: UpgradeWorkflowOptions);
-}