tessl/npm-projen

CDK for software projects - synthesizes configuration files from well-typed JavaScript/TypeScript definitions.

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Overview

Eval results

Files

Java Projects

Name: tessl/npm-projen
Author: tessl

Java projects with Maven build system and dependency management. Provides comprehensive setup for Java applications and libraries with modern Java development tools.

Capabilities

JavaProject Class

Main Java project class with Maven build system and integrated Java tooling.

/**
 * Java project with Maven build system and dependency management
 * Provides complete Java development environment
 */
class JavaProject extends GitHubProject {
  constructor(options: JavaProjectOptions);
  
  /** Maven POM file management */
  readonly pom: Pom;
  /** JUnit testing framework (if enabled) */
  readonly junit?: Junit;
  /** Maven packaging configuration */
  readonly packaging: MavenPackaging;
  /** Maven compilation setup */
  readonly compile: MavenCompile;
  /** Distribution directory */
  readonly distdir: string;
  /** Java package name */
  readonly packageName: string;
}

interface JavaProjectOptions extends GitHubProjectOptions {
  /** Maven group ID */
  groupId?: string;
  /** Maven artifact ID */
  artifactId?: string;
  /** Package version */
  version?: string;
  /** Main class for applications */
  mainClass?: string;
  /** Java package name */
  packageName?: string;
  /** Java version (default: "11") */
  javaVersion?: string;
  /** Maven packaging type */
  packaging?: MavenPackaging;
  /** Distribution directory (default: "dist") */
  distdir?: string;
  
  /** Enable JUnit testing */
  junit?: boolean;
  /** JUnit version */
  junitVersion?: string;
  
  /** Enable sample code generation */
  sample?: boolean;
  /** Sample Java class name */
  sampleJavaPackage?: string;
}

enum MavenPackaging {
  JAR = "jar",
  WAR = "war",
  POM = "pom"
}

Basic Java Project Example:

import { JavaProject, MavenPackaging } from "projen";

const project = new JavaProject({
  name: "my-java-app",
  defaultReleaseBranch: "main",
  
  // Maven configuration
  groupId: "com.example",
  artifactId: "my-java-app",
  version: "1.0.0",
  mainClass: "com.example.App",
  
  // Java configuration
  javaVersion: "17",
  packaging: MavenPackaging.JAR,
  
  // Project metadata
  description: "My awesome Java application",
  
  // Enable JUnit testing
  junit: true,
  junitVersion: "5.9.0",
  
  // Generate sample code
  sample: true,
  sampleJavaPackage: "com.example",
});

Pom Class

Maven POM file management for Java projects.

/**
 * Maven POM file management for Java projects
 * Handles dependencies, plugins, and build configuration
 */
class Pom extends Component {
  constructor(project: JavaProject, options?: PomOptions);
  
  /** Maven group ID */
  readonly groupId: string;
  /** Maven artifact ID */
  readonly artifactId: string;
  /** Project version */
  readonly version: string;
  /** Packaging type */
  readonly packaging: string;
  
  /** Add runtime dependency */
  addDependency(groupId: string, artifactId: string, version?: string, options?: MavenDependencyOptions): void;
  /** Add test dependency */
  addTestDependency(groupId: string, artifactId: string, version?: string): void;
  /** Add plugin */
  addPlugin(groupId: string, artifactId: string, version?: string, options?: MavenPluginOptions): void;
  /** Add repository */
  addRepository(id: string, url: string, options?: MavenRepositoryOptions): void;
  /** Add property */
  addProperty(key: string, value: string): void;
}

interface PomOptions {
  /** Maven group ID */
  groupId?: string;
  /** Maven artifact ID */
  artifactId?: string;
  /** Project version */
  version?: string;
  /** Packaging type */
  packaging?: string;
  /** Project description */
  description?: string;
  /** Project URL */
  url?: string;
}

interface MavenDependencyOptions {
  /** Dependency scope */
  scope?: "compile" | "test" | "runtime" | "provided";
  /** Dependency type */
  type?: string;
  /** Optional dependency */
  optional?: boolean;
  /** Exclusions */
  exclusions?: Array<{
    groupId: string;
    artifactId: string;
  }>;
}

Maven Configuration Example:

import { JavaProject } from "projen";

const project = new JavaProject({
  name: "spring-boot-app",
  groupId: "com.example",
  artifactId: "spring-boot-app",
  version: "1.0.0",
});

// Add Spring Boot dependencies
project.pom.addProperty("spring-boot.version", "3.1.0");

project.pom.addDependency(
  "org.springframework.boot",
  "spring-boot-starter-web",
  "${spring-boot.version}"
);

project.pom.addDependency(
  "org.springframework.boot", 
  "spring-boot-starter-data-jpa",
  "${spring-boot.version}"
);

// Add database driver
project.pom.addDependency(
  "org.postgresql",
  "postgresql",
  "42.6.0",
  { scope: "runtime" }
);

// Add test dependencies
project.pom.addTestDependency(
  "org.springframework.boot",
  "spring-boot-starter-test",
  "${spring-boot.version}"
);

// Add Spring Boot Maven plugin
project.pom.addPlugin(
  "org.springframework.boot",
  "spring-boot-maven-plugin",
  "${spring-boot.version}",
  {
    executions: [{
      goals: ["repackage"],
    }],
  }
);

JUnit Testing

JUnit testing framework setup for Java projects.

/**
 * JUnit testing framework for Java projects
 * Supports JUnit 4 and JUnit 5 (Jupiter)
 */
class Junit extends Component {
  constructor(project: JavaProject, options?: JunitOptions);
  
  /** JUnit version */
  readonly version: string;
  /** Test task */
  readonly testTask: Task;
}

interface JunitOptions {
  /** JUnit version (4 or 5) */
  version?: string;
  /** Include JUnit Jupiter engine for JUnit 5 */
  includeJupiter?: boolean;
}

Maven Compilation

Maven compilation configuration for Java projects.

/**
 * Maven compilation configuration
 * Manages Java compiler settings and source/target versions
 */
class MavenCompile extends Component {
  constructor(project: JavaProject, options?: MavenCompileOptions);
  
  /** Java source version */
  readonly source: string;
  /** Java target version */
  readonly target: string;
}

interface MavenCompileOptions {
  /** Java source version */
  source?: string;
  /** Java target version */
  target?: string;
  /** Compiler arguments */
  compilerArgs?: string[];
  /** Show deprecation warnings */
  showDeprecation?: boolean;
  /** Show unchecked warnings */
  showUnchecked?: boolean;
}

Maven Sample Files

Generate sample Java code and test files.

/**
 * Maven sample code generation
 * Creates example Java classes and test files
 */
class MavenSample extends Component {
  constructor(project: JavaProject, options?: MavenSampleOptions);
}

interface MavenSampleOptions {
  /** Sample package name */
  packageName?: string;
  /** Sample class name */
  className?: string;
}

Complete Java Project Example:

import { JavaProject, MavenPackaging } from "projen";

const project = new JavaProject({
  name: "enterprise-java-app",
  defaultReleaseBranch: "main",
  
  // Maven configuration
  groupId: "com.enterprise",
  artifactId: "enterprise-java-app", 
  version: "1.0.0",
  mainClass: "com.enterprise.Application",
  packaging: MavenPackaging.JAR,
  
  // Java version
  javaVersion: "17",
  
  // Project metadata
  description: "Enterprise Java application with Spring Boot",
  
  // Enable testing
  junit: true,
  junitVersion: "5.9.0",
  
  // Sample code
  sample: true,
  sampleJavaPackage: "com.enterprise",
});

// Configure Maven properties
project.pom.addProperty("maven.compiler.source", "17");
project.pom.addProperty("maven.compiler.target", "17");
project.pom.addProperty("spring-boot.version", "3.1.0");
project.pom.addProperty("junit.version", "5.9.0");

// Add Spring Boot dependencies
project.pom.addDependency(
  "org.springframework.boot",
  "spring-boot-starter-web",
  "${spring-boot.version}"
);

project.pom.addDependency(
  "org.springframework.boot",
  "spring-boot-starter-actuator", 
  "${spring-boot.version}"
);

project.pom.addDependency(
  "org.springframework.boot",
  "spring-boot-starter-security",
  "${spring-boot.version}"
);

// Add utility dependencies
project.pom.addDependency("org.apache.commons", "commons-lang3", "3.12.0");
project.pom.addDependency("com.fasterxml.jackson.core", "jackson-databind", "2.15.0");

// Add test dependencies
project.pom.addTestDependency(
  "org.springframework.boot",
  "spring-boot-starter-test",
  "${spring-boot.version}"
);

project.pom.addTestDependency("org.testcontainers", "junit-jupiter", "1.18.0");
project.pom.addTestDependency("org.testcontainers", "postgresql", "1.18.0");

// Add Maven plugins
project.pom.addPlugin(
  "org.apache.maven.plugins",
  "maven-compiler-plugin",
  "3.11.0",
  {
    configuration: {
      source: "17",
      target: "17",
      compilerArgs: ["-parameters"],
    },
  }
);

project.pom.addPlugin(
  "org.springframework.boot",
  "spring-boot-maven-plugin",
  "${spring-boot.version}",
  {
    executions: [{
      goals: ["repackage"],
    }],
    configuration: {
      mainClass: "com.enterprise.Application",
    },
  }
);

project.pom.addPlugin(
  "org.apache.maven.plugins",
  "maven-surefire-plugin",
  "3.0.0",
  {
    configuration: {
      includes: ["**/*Test.java", "**/*Tests.java"],
    },
  }
);

// Add custom tasks
project.addTask("run", {
  description: "Run the application",
  exec: "mvn spring-boot:run",
});

project.addTask("package", {
  description: "Package the application",
  exec: "mvn clean package",
});

project.addTask("test:integration", {
  description: "Run integration tests",
  exec: "mvn test -Dtest=**/*IntegrationTest",
});

Types

Java-Specific Types

interface MavenPluginOptions {
  /** Plugin configuration */
  configuration?: Record<string, any>;
  /** Plugin executions */
  executions?: Array<{
    id?: string;
    phase?: string;
    goals: string[];
    configuration?: Record<string, any>;
  }>;
  /** Plugin dependencies */
  dependencies?: Array<{
    groupId: string;
    artifactId: string;
    version: string;
  }>;
}

interface MavenRepositoryOptions {
  /** Repository name */
  name?: string;
  /** Repository layout */
  layout?: string;
  /** Repository releases policy */
  releases?: {
    enabled?: boolean;
    updatePolicy?: "always" | "daily" | "interval" | "never";
    checksumPolicy?: "fail" | "ignore" | "warn";
  };
  /** Repository snapshots policy */  
  snapshots?: {
    enabled?: boolean;
    updatePolicy?: "always" | "daily" | "interval" | "never";
    checksumPolicy?: "fail" | "ignore" | "warn";
  };
}

interface PomProject {
  groupId: string;
  artifactId: string;
  version: string;
  packaging?: string;
  name?: string;
  description?: string;
  url?: string;
  properties?: Record<string, string>;
  dependencies?: MavenDependency[];
  plugins?: MavenPlugin[];
  repositories?: MavenRepository[];
}

Install with Tessl CLI