Dependency Management

/**
 * Manages project dependencies across different package managers
 * Provides unified interface for npm, pip, Maven, etc.
 */
class Dependencies extends Component {
  constructor(project: Project);
  
  /** All dependencies in the project */
  readonly all: Dependency[];
  
  /** Add a dependency to the project */
  addDependency(spec: string, type: DependencyType, metadata?: object): Dependency;
  /** Remove a dependency from the project */
  removeDependency(name: string, type?: DependencyType): void;
  /** Get a dependency by name and type */
  getDependency(name: string, type?: DependencyType): Dependency;
  /** Try to get a dependency (returns undefined if not found) */
  tryGetDependency(name: string, type?: DependencyType): Dependency | undefined;
  /** Check if a dependency version requirement is satisfied */
  isDependencySatisfied(name: string, type: DependencyType, expectedRange: string): boolean;
  
  /** Parse a dependency specification string */
  static parseDependency(spec: string): DependencyCoordinates;
}

interface Dependency {
  /** Package name */
  name: string;
  /** Version requirement (semver range, exact version, etc.) */
  version?: string;
  /** Dependency type classification */
  type: DependencyType;
  /** Additional metadata (registry, source, etc.) */
  metadata?: object;
}

interface DependencyCoordinates {
  /** Package name */
  name: string;
  /** Version specification */
  version?: string;
  /** Package source/registry */
  source?: string;
}

enum DependencyType {
  /** Runtime dependencies - required for production */
  RUNTIME = "runtime",
  /** Peer dependencies - provided by consuming application */
  PEER = "peer",
  /** Bundled dependencies - included in package distribution */
  BUNDLED = "bundled",
  /** Build dependencies - required for building */
  BUILD = "build",
  /** Test dependencies - required for testing only */
  TEST = "test",
  /** Development environment dependencies */
  DEVENV = "devenv",
  /** Override dependencies - override transitive dependency versions */
  OVERRIDE = "override",
  /** Optional dependencies - not required but enhance functionality */
  OPTIONAL = "optional"
}

import { Project, DependencyType } from "projen";

const project = new Project({ name: "dependency-example" });

// Add runtime dependencies
project.deps.addDependency("axios@^1.0.0", DependencyType.RUNTIME);
project.deps.addDependency("lodash", DependencyType.RUNTIME, {
  source: "npm",
});

// Add development dependencies
project.deps.addDependency("@types/node", DependencyType.BUILD);
project.deps.addDependency("jest", DependencyType.TEST);

// Add peer dependencies
project.deps.addDependency("react@>=16.0.0", DependencyType.PEER);

// Check if dependency exists
const axios = project.deps.tryGetDependency("axios", DependencyType.RUNTIME);
if (axios) {
  console.log(`Axios version: ${axios.version}`);
}

// Remove a dependency
project.deps.removeDependency("lodash", DependencyType.RUNTIME);

/**
 * Node.js package.json management
 * Handles npm/yarn dependencies and package configuration
 */
class NodePackage extends Component {
  constructor(project: NodeProject, options?: NodePackageOptions);
  
  /** Package name */
  readonly packageName: string;
  /** Package version */
  readonly version: string;
  /** Runtime dependencies */
  readonly deps: Record<string, string>;
  /** Development dependencies */
  readonly devDeps: Record<string, string>;
  /** Peer dependencies */
  readonly peerDeps: Record<string, string>;
  /** Optional dependencies */
  readonly optionalDeps: Record<string, string>;
  /** Bundled dependencies */
  readonly bundledDeps: string[];
  
  /** Add runtime dependency */
  addDep(spec: string): void;
  /** Add development dependency */
  addDevDep(spec: string): void;
  /** Add peer dependency */
  addPeerDep(spec: string): void;
  /** Add optional dependency */
  addOptionalDep(spec: string): void;
  /** Add bundled dependency */
  addBundledDep(spec: string): void;
  
  /** Remove any type of dependency */
  removeDep(name: string): void;
  /** Check if dependency exists */
  hasDep(name: string): boolean;
  
  /** Add npm script */
  addScript(name: string, command: string): void;
  /** Remove npm script */
  removeScript(name: string): void;
  
  /** Add package.json field */
  addField(name: string, value: any): void;
}

interface NodePackageOptions {
  /** Package name override */
  packageName?: string;
  /** Package version */
  version?: string;
  /** Package description */
  description?: string;
  /** Package keywords */
  keywords?: string[];
  /** Package license */
  license?: string;
  /** Author information */
  author?: string | AuthorOptions;
  /** Repository information */
  repository?: string | RepositoryOptions;
  /** Homepage URL */
  homepage?: string;
  /** Bug tracker URL */
  bugs?: string | BugsOptions;
}

import { NodeProject } from "projen";

const project = new NodeProject({
  name: "my-node-package",
  version: "1.0.0",
  description: "Example Node.js package",
  
  // Dependencies
  deps: [
    "express@^4.18.0",
    "cors@^2.8.5",
  ],
  devDeps: [
    "@types/express",
    "@types/cors",
    "typescript",
    "jest",
  ],
  peerDeps: [
    "react@>=16.0.0",
  ],
});

// Add custom npm scripts
project.package.addScript("start", "node dist/index.js");
project.package.addScript("dev", "ts-node src/index.ts");

// Add custom package.json fields
project.package.addField("engines", {
  node: ">=16.0.0",
  npm: ">=8.0.0",
});

// Dynamic dependency management
project.package.addDep("moment@^2.29.0");
project.package.addDevDep("@types/moment");

/**
 * Python pip dependency management
 * Manages requirements.txt and setup.py dependencies
 */
class Pip extends Component {
  constructor(project: PythonProject, options?: PipOptions);
  
  /** Install a package */
  addDependency(spec: string): void;
  /** Install a development dependency */
  addDevDependency(spec: string): void;
  /** Remove a dependency */
  removeDependency(name: string): void;
}

/**
 * Poetry dependency management for Python
 * Manages pyproject.toml and poetry.lock
 */
class Poetry extends Component {
  constructor(project: PythonProject, options?: PoetryOptions);
  
  /** Add runtime dependency */
  addDependency(name: string, requirement?: string): void;
  /** Add development dependency */
  addDevDependency(name: string, requirement?: string): void;
  /** Add dependency group */
  addGroup(name: string, dependencies: Record<string, string>): void;
}

interface PipOptions {
  /** Install from requirements.txt */
  installRequirements?: boolean;
  /** Requirements file name */
  requirementsFile?: string;
}

interface PoetryOptions {
  /** Poetry version */
  version?: string;
  /** Python version requirement */
  pythonVersion?: string;
  /** Poetry configuration */
  config?: Record<string, any>;
}

import { PythonProject } from "projen";

const project = new PythonProject({
  name: "my-python-package",
  moduleName: "my_package",
  
  // Use Poetry for dependency management
  poetry: true,
  
  // Dependencies
  deps: [
    "requests>=2.28.0",
    "click>=8.0.0",
  ],
  devDeps: [
    "pytest>=7.0.0",
    "black>=22.0.0",
    "mypy>=1.0.0",
  ],
});

// Add additional dependencies programmatically
if (project.poetry) {
  project.poetry.addDependency("pydantic", "^1.10.0");
  project.poetry.addDevDependency("pytest-cov", "^4.0.0");
  
  // Add dependency groups
  project.poetry.addGroup("docs", {
    "sphinx": "^5.0.0",
    "sphinx-rtd-theme": "^1.0.0",
  });
}

/**
 * Maven POM file management for Java projects
 * Handles dependencies, plugins, and build configuration
 */
class Pom extends Component {
  constructor(project: JavaProject, options?: PomOptions);
  
  /** 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;
}

interface MavenDependencyOptions {
  /** Dependency scope (compile, test, runtime, etc.) */
  scope?: string;
  /** Dependency type */
  type?: string;
  /** Optional dependency */
  optional?: boolean;
  /** Exclusions */
  exclusions?: Array<{
    groupId: string;
    artifactId: string;
  }>;
}

interface PomOptions {
  /** Group ID */
  groupId?: string;
  /** Artifact ID */
  artifactId?: string;
  /** Version */
  version?: string;
  /** Packaging type */
  packaging?: string;
  /** Project description */
  description?: string;
}

import { JavaProject } from "projen";

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

// Add dependencies
project.pom.addDependency("org.springframework", "spring-core", "5.3.22");
project.pom.addDependency("org.slf4j", "slf4j-api", "1.7.36");

// Add test dependencies
project.pom.addTestDependency("junit", "junit", "4.13.2");
project.pom.addTestDependency("org.mockito", "mockito-core", "4.6.1");

// Add Maven plugins
project.pom.addPlugin("org.apache.maven.plugins", "maven-compiler-plugin", "3.8.1", {
  configuration: {
    source: "11",
    target: "11",
  },
});

// Add custom repository
project.pom.addRepository("central", "https://repo1.maven.org/maven2/");

/**
 * Automated dependency upgrades for Node.js projects
 * Creates workflows to keep dependencies up to date
 */
class UpgradeDependencies extends Component {
  constructor(project: NodeProject, options?: UpgradeDependenciesOptions);
}

interface UpgradeDependenciesOptions {
  /** Upgrade workflow name */
  workflowName?: string;
  /** Upgrade schedule (cron expression) */
  schedule?: string;
  /** Include development dependencies */
  include?: string[];
  /** Exclude specific dependencies */
  exclude?: string[];
  /** Target branch for upgrade PRs */
  targetBranch?: string;
}

interface AuthorOptions {
  name: string;
  email?: string;
  url?: string;
  organization?: boolean;
}

interface RepositoryOptions {
  type: string;
  url: string;
  directory?: string;
}

interface BugsOptions {
  url?: string;
  email?: string;
}

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

interface MavenRepositoryOptions {
  /** Repository layout */
  layout?: string;
  /** Repository releases policy */
  releases?: {
    enabled?: boolean;
    updatePolicy?: string;
  };
  /** Repository snapshots policy */
  snapshots?: {
    enabled?: boolean;
    updatePolicy?: string;
  };
}