@orsetra/camel-pom-gen 1.0.0

package/src/catalogs/index.ts

@@ -0,0 +1,23 @@
+import { CAMEL_CATALOG_3_15_3 } from './catalog-3.15.3'
+// Add when available: import { CAMEL_CATALOG_3_39_X } from './catalog-3.39.x'
+
+import { parseCatalogYaml } from '../catalog/catalog'
+import type { CamelCatalog } from '../catalog/types'
+
+const BUNDLED_CATALOGS: Record<string, string> = {
+  '3.15.3': CAMEL_CATALOG_3_15_3,
+  // '3.39.x': CAMEL_CATALOG_3_39_X,
+}
+
+/**
+ * Get a bundled CamelCatalog by catalogVersion (e.g. "3.15.3").
+ * Returns undefined if the version is not bundled — caller should
+ * fall back to a user-provided catalog via parseCatalogYaml().
+ */
+export function getBundledCatalog(catalogVersion: string): CamelCatalog | undefined {
+  const raw = BUNDLED_CATALOGS[catalogVersion]
+  return raw ? parseCatalogYaml(raw) : undefined
+}
+
+/** All bundled catalog versions. */
+export const BUNDLED_CATALOG_VERSIONS = Object.keys(BUNDLED_CATALOGS)

package/src/config.ts

@@ -0,0 +1,79 @@
+/**
+ * Runtime configuration aligned with official Camel K operator releases.
+ *
+ * Sources:
+ *   - pkg/util/defaults/defaults.go (per tag in the repo)
+ *   - pkg/builder/quarkus.go → generateQuarkusProjectCommon
+ *   - https://camel.apache.org/blog/2026/09/camel-k-2-11/
+ */
+
+export type RuntimeFlavor = 'plain-quarkus' | 'quarkus'
+
+export interface CamelKRuntimeConfig {
+  /** Camel K operator version (e.g. "2.11.0"). */
+  operatorVersion: string
+  /** DSL runtime flavor. */
+  flavor: RuntimeFlavor
+  /**
+   * For plain-quarkus: Quarkus Platform version used as BOM version AND as
+   *   quarkus-maven-plugin version (matches `runtimeVersion` in defaults.go).
+   * For legacy quarkus: camel-k-runtime BOM version.
+   */
+  runtimeVersion: string
+  /**
+   * For legacy quarkus: the Quarkus version from the catalog metadata
+   *   (catalog.runtime.metadata["quarkus.version"]) — used as quarkus-maven-plugin
+   *   version only.
+   * For plain-quarkus: same as runtimeVersion (field can be omitted).
+   */
+  quarkusPlatformVersion?: string
+  /** Human-readable Camel core version shipped with this config. */
+  camelVersion: string
+  /** Catalog YAML file version (camel-catalog-<catalogVersion>.yaml). */
+  catalogVersion: string
+}
+
+/** Resolved quarkus-maven-plugin version for the given config. */
+export function getQuarkusPluginVersion(config: CamelKRuntimeConfig): string {
+  if (config.flavor === 'plain-quarkus') return config.runtimeVersion
+  return config.quarkusPlatformVersion ?? config.runtimeVersion
+}
+
+/**
+ * Known Camel K release → runtime mappings.
+ * Add new entries when upgrading the operator.
+ */
+export const OPERATOR_RUNTIME_CONFIGS: CamelKRuntimeConfig[] = [
+  {
+    operatorVersion: '2.11.0',
+    flavor: 'plain-quarkus',
+    runtimeVersion: '3.39.1',           // Quarkus Platform — BOM + plugin version
+    camelVersion: '4.22.0',
+    catalogVersion: '3.15.3',
+  },
+  {
+    operatorVersion: '2.10.0',
+    flavor: 'quarkus',
+    runtimeVersion: '3.15.3',           // camel-k-runtime BOM version
+    quarkusPlatformVersion: '3.15.4',   // quarkus.version from catalog metadata
+    camelVersion: '4.8.5',
+    catalogVersion: '3.15.3',
+  },
+  {
+    operatorVersion: '2.9.0',
+    flavor: 'quarkus',
+    runtimeVersion: '3.14.0',
+    quarkusPlatformVersion: '3.14.0',
+    camelVersion: '4.7.0',
+    catalogVersion: '3.14.0',
+  },
+]
+
+/** Get the runtime config for a given operator version (exact match, then latest). */
+export function getRuntimeConfig(operatorVersion: string): CamelKRuntimeConfig {
+  return OPERATOR_RUNTIME_CONFIGS.find(c => c.operatorVersion === operatorVersion)
+      ?? OPERATOR_RUNTIME_CONFIGS[0]
+}
+
+/** Default config (latest supported operator version). */
+export const DEFAULT_CONFIG = OPERATOR_RUNTIME_CONFIGS[0]

package/src/dependencies/manager.ts

@@ -0,0 +1,176 @@
+/**
+ * Dependency manager — mirrors pkg/util/camel/camel_dependencies.go.
+ */
+import type { CamelCatalog } from '../catalog/types'
+import type { MavenDependency, MavenProject, MavenRepository } from './types'
+
+const JITPACK_REPO_URL = 'https://jitpack.io'
+const QUARKUS_GROUP_ID = 'org.apache.camel.quarkus'
+
+// ─── Project factory ──────────────────────────────────────────────────────────
+
+export function createProject(groupId: string, artifactId: string, version: string): MavenProject {
+  return {
+    groupId,
+    artifactId,
+    version,
+    properties: {},
+    boms: [],
+    dependencies: [],
+    exclusions: new Map(),
+    repositories: [],
+    pluginRepositories: [],
+    build: { plugins: [] },
+    profiles: [],
+  }
+}
+
+// ─── Dependency adders ────────────────────────────────────────────────────────
+
+/** Add a Maven dependency (deduplicates by groupId:artifactId). */
+export function addDependency(project: MavenProject, dep: MavenDependency): void {
+  const key = `${dep.groupId}:${dep.artifactId}`
+  if (!project.dependencies.some(d => `${d.groupId}:${d.artifactId}` === key)) {
+    project.dependencies.push(dep)
+  }
+}
+
+export function addDependencyGAV(project: MavenProject, groupId: string, artifactId: string, version = ''): void {
+  addDependency(project, { groupId, artifactId, ...(version ? { version } : {}) })
+}
+
+/**
+ * Process a raw dependency string (camel:xxx, mvn:g:a:v, bom:g:a:v,
+ * camel-k:xxx, camel-quarkus:xxx, or a GitHub JitPack coords).
+ */
+export function applyDependency(
+  project: MavenProject,
+  catalog: CamelCatalog,
+  dep: string,
+): string | null {
+  if (dep.startsWith('bom:'))           return applyBOM(project, dep)
+  if (dep.startsWith('camel:'))         { applyCamelComponent(project, catalog, dep); return null }
+  if (dep.startsWith('camel-k:'))       { applyCamelKComponent(project, dep); return null }
+  if (dep.startsWith('camel-quarkus:')) { applyCamelQuarkusComponent(project, dep); return null }
+  if (dep.startsWith('mvn:'))           { applyMavenDependency(project, dep); return null }
+  if (dep.startsWith('github:'))        return applyJitPack(project, dep)
+  return `Unknown dependency format: ${dep}`
+}
+
+function applyBOM(project: MavenProject, dep: string): string | null {
+  const gav = dep.slice('bom:'.length)
+  const parts = gav.split(':')
+  if (parts.length < 3) return `Invalid BOM format: ${dep}`
+  project.boms.push({ groupId: parts[0], artifactId: parts[1], version: parts[2] })
+  return null
+}
+
+function applyCamelComponent(project: MavenProject, catalog: CamelCatalog, dep: string): void {
+  let artifactId = dep.slice('camel:'.length)
+  const isQuarkus = catalog.runtime.provider === 'quarkus' || catalog.runtime.provider === 'plain-quarkus'
+  if (isQuarkus) {
+    if (!artifactId.startsWith('camel-')) artifactId = 'camel-quarkus-' + artifactId
+    addDependencyGAV(project, QUARKUS_GROUP_ID, artifactId)
+  } else {
+    if (!artifactId.startsWith('camel-')) artifactId = 'camel-' + artifactId
+    addDependencyGAV(project, 'org.apache.camel', artifactId)
+  }
+}
+
+function applyCamelKComponent(project: MavenProject, dep: string): void {
+  let artifactId = dep.slice('camel-k:'.length)
+  if (!artifactId.startsWith('camel-k-')) artifactId = 'camel-k-' + artifactId
+  addDependencyGAV(project, 'org.apache.camel.k', artifactId)
+}
+
+function applyCamelQuarkusComponent(project: MavenProject, dep: string): void {
+  let artifactId = dep.slice('camel-quarkus:'.length)
+  if (!artifactId.startsWith('camel-quarkus-')) artifactId = 'camel-quarkus-' + artifactId
+  addDependencyGAV(project, QUARKUS_GROUP_ID, artifactId)
+}
+
+/** `mvn:groupId:artifactId` or `mvn:groupId:artifactId:version` */
+function applyMavenDependency(project: MavenProject, dep: string): void {
+  const gav = dep.slice('mvn:'.length)
+  const parts = gav.split(':')
+  if (parts.length >= 2) addDependencyGAV(project, parts[0], parts[1], parts[2])
+}
+
+function applyJitPack(project: MavenProject, dep: string): string | null {
+  const coords = dep.slice('github:'.length)
+  const parts = coords.split('/')
+  if (parts.length < 3) return `Invalid JitPack format: ${dep}`
+  const [org, repo, version] = parts
+  addDependency(project, { groupId: `com.github.${org}`, artifactId: repo, version })
+  addJitPackRepo(project)
+  return null
+}
+
+function addJitPackRepo(project: MavenProject): void {
+  if (!project.repositories.some(r => r.url === JITPACK_REPO_URL)) {
+    const repo: MavenRepository = {
+      id: 'jitpack.io',
+      url: JITPACK_REPO_URL,
+      releases:  { enabled: true, checksumPolicy: 'fail' },
+      snapshots: { enabled: true, checksumPolicy: 'fail' },
+    }
+    project.repositories.push(repo)
+  }
+}
+
+// ─── Post-processing ──────────────────────────────────────────────────────────
+
+/**
+ * Add transitive dependencies from the catalog for every artifact already in the project.
+ * Mirrors addDependenciesFromCatalog() in camel_dependencies.go.
+ */
+export function addTransitiveDeps(project: MavenProject, catalog: CamelCatalog): void {
+  const snapshot = [...project.dependencies]
+  for (const dep of snapshot) {
+    const artifact = catalog.artifacts[dep.artifactId]
+    if (!artifact) continue
+    for (const transitive of artifact.dependencies ?? []) {
+      addDependency(project, {
+        groupId: transitive.groupId,
+        artifactId: transitive.artifactId,
+        ...(transitive.type       ? { type: transitive.type } : {}),
+        ...(transitive.classifier ? { classifier: transitive.classifier } : {}),
+      })
+    }
+    const key = `${artifact.groupId}:${artifact.artifactId}`
+    const excls = artifact.exclusions ?? []
+    if (excls.length > 0) {
+      project.exclusions.set(key, [...(project.exclusions.get(key) ?? []), ...excls])
+    }
+  }
+}
+
+/**
+ * Strip versions from Camel/Camel-K/Camel-Quarkus artifacts so the BOM manages them.
+ * Mirrors SanitizeIntegrationDependencies() in camel_dependencies.go.
+ */
+export function sanitizeDependencies(project: MavenProject): void {
+  const managed = new Set(['org.apache.camel', 'org.apache.camel.k', 'org.apache.camel.quarkus'])
+  for (const dep of project.dependencies) {
+    if (managed.has(dep.groupId)) dep.version = undefined
+  }
+}
+
+/**
+ * Apply all dependency strings, resolve transitives, and sanitize versions.
+ * Mirrors ManageIntegrationDependencies() in camel_dependencies.go.
+ */
+export function manageIntegrationDependencies(
+  project: MavenProject,
+  catalog: CamelCatalog,
+  dependencies: string[],
+): string[] {
+  const errors: string[] = []
+  for (const dep of dependencies) {
+    const err = applyDependency(project, catalog, dep)
+    if (err) errors.push(err)
+  }
+  addTransitiveDeps(project, catalog)
+  sanitizeDependencies(project)
+  return errors
+}

package/src/dependencies/normalizer.ts

@@ -0,0 +1,27 @@
+/**
+ * Dependency normalizer — mirrors pkg/util/camel/camel_dependencies.go → NormalizeDependency.
+ *
+ * Converts all the forms accepted by kamel CLI into the canonical `camel:xxx` form:
+ *   camel-timer            → camel:timer
+ *   camel-quarkus-timer    → camel:timer
+ *   camel-quarkus:timer    → camel:timer
+ *   camel-k-cron           → camel-k:cron
+ */
+export function normalizeDependency(dep: string): string {
+  if (dep.startsWith('camel-quarkus-')) return 'camel:' + dep.slice('camel-quarkus-'.length)
+  if (dep.startsWith('camel-quarkus:'))  return 'camel:' + dep.slice('camel-quarkus:'.length)
+  if (dep.startsWith('camel-k-'))        return 'camel-k:' + dep.slice('camel-k-'.length)
+  if (dep.startsWith('camel-k:'))        return dep
+  if (dep.startsWith('camel-'))          return 'camel:' + dep.slice('camel-'.length)
+  return dep
+}
+
+/** Validate that a `camel:xxx` dependency exists in the catalog artifacts. */
+export function validateCamelDep(artifactKeys: Set<string>, dep: string): boolean {
+  if (dep.startsWith('camel:')) {
+    const name = dep.slice('camel:'.length)
+    // catalog keys are like "camel-quarkus-timer"
+    return artifactKeys.has('camel-quarkus-' + name) || artifactKeys.has('camel-' + name)
+  }
+  return true
+}

package/src/dependencies/types.ts

@@ -0,0 +1,75 @@
+export interface MavenDependency {
+  groupId: string
+  artifactId: string
+  version?: string
+  scope?: string
+  type?: string
+  classifier?: string
+}
+
+export interface MavenExclusion {
+  groupId: string
+  artifactId: string
+}
+
+export interface MavenExecution {
+  id?: string
+  phase?: string
+  goals: string[]
+}
+
+export interface MavenPlugin {
+  groupId: string
+  artifactId: string
+  version?: string
+  /** <extensions>true</extensions> — required by quarkus-maven-plugin */
+  extensions?: boolean
+  executions?: MavenExecution[]
+  dependencies?: MavenDependency[]
+  /** Raw XML string injected verbatim inside <configuration>...</configuration> */
+  configurationXml?: string
+}
+
+export interface MavenProfile {
+  id: string
+  activeByDefault?: boolean
+  /** Plugins in the profile's <build> section */
+  plugins?: MavenPlugin[]
+  /** Raw XML string injected verbatim for the entire profile when needed */
+  rawXml?: string
+}
+
+export interface MavenRepository {
+  id: string
+  url: string
+  name?: string
+  releases?: { enabled: boolean; checksumPolicy?: string }
+  snapshots?: { enabled: boolean; checksumPolicy?: string }
+}
+
+export interface MavenBOM {
+  groupId: string
+  artifactId: string
+  version: string
+}
+
+/**
+ * In-memory representation of a Maven project before serialization.
+ * Mirrors pkg/util/maven/maven_types.go → Project struct.
+ */
+export interface MavenProject {
+  groupId: string
+  artifactId: string
+  version: string
+  properties: Record<string, string>
+  /** BOM imports (dependencyManagement) */
+  boms: MavenBOM[]
+  dependencies: MavenDependency[]
+  exclusions: Map<string, MavenExclusion[]>  // key = "groupId:artifactId"
+  repositories: MavenRepository[]
+  pluginRepositories: MavenRepository[]
+  build: {
+    plugins: MavenPlugin[]
+  }
+  profiles: MavenProfile[]
+}

package/src/fs-provider.ts

@@ -0,0 +1,99 @@
+/**
+ * FileSystemProvider — abstraction over file system access.
+ *
+ * The package never touches the real filesystem directly.
+ * The host IDE registers an implementation at startup via init().
+ *
+ * Two reference implementations:
+ *   nodeFsProvider(fs)   — Node.js fs module (desktop / server-side IDE)
+ *   memFsProvider(map)   — in-memory map (tests, browser IDEs with files already loaded)
+ */
+export interface FileSystemProvider {
+  /**
+   * Read a file and return its UTF-8 content.
+   * Throw / reject when the file does not exist.
+   */
+  readFile(path: string): string | Promise<string>
+
+  /**
+   * List all files recursively under `dir`.
+   * Returns full paths (same format as the paths passed to readFile).
+   * Returns an empty array when the directory does not exist.
+   */
+  listFiles(dir: string): string[] | Promise<string[]>
+}
+
+// ── Registry ──────────────────────────────────────────────────────────────────
+
+let _fs: FileSystemProvider | undefined
+
+export function registerFsProvider(provider: FileSystemProvider): void {
+  _fs = provider
+}
+
+export function getFsProvider(): FileSystemProvider {
+  if (!_fs) throw new Error(
+    '[camel-pom-gen] No FileSystemProvider registered. ' +
+    'Call init() before syncPom().',
+  )
+  return _fs
+}
+
+// ── Reference implementations ─────────────────────────────────────────────────
+
+/**
+ * Node.js provider.
+ * Pass the `fs` module (or `fs/promises`) and the `path` module.
+ *
+ * @example
+ * import fs from 'fs'
+ * import path from 'path'
+ * init({ ..., fs: nodeFsProvider(fs, path) })
+ */
+export function nodeFsProvider(
+  nodeFs: {
+    readFileSync(p: string, enc: 'utf8'): string
+    readdirSync(p: string, opts: { withFileTypes: true }): Array<{ name: string; isDirectory(): boolean }>
+  },
+  nodePath: { join(...parts: string[]): string },
+): FileSystemProvider {
+  function walk(dir: string): string[] {
+    let entries: Array<{ name: string; isDirectory(): boolean }>
+    try { entries = nodeFs.readdirSync(dir, { withFileTypes: true }) }
+    catch { return [] }
+    const files: string[] = []
+    for (const e of entries) {
+      const full = nodePath.join(dir, e.name)
+      if (e.isDirectory()) files.push(...walk(full))
+      else files.push(full)
+    }
+    return files
+  }
+  return {
+    readFile:  (p) => nodeFs.readFileSync(p, 'utf8'),
+    listFiles: (dir) => walk(dir),
+  }
+}
+
+/**
+ * In-memory provider — map of path → content.
+ * listFiles returns all paths that start with the given dir prefix.
+ *
+ * @example
+ * init({ ..., fs: memFsProvider({
+ *   'src/main/resources/route.yaml': '...',
+ *   'src/main/java/Processor.java':  '...',
+ * }) })
+ */
+export function memFsProvider(files: Record<string, string>): FileSystemProvider {
+  return {
+    readFile: (path) => {
+      if (!(path in files)) throw new Error(`[camel-pom-gen] File not found: ${path}`)
+      return files[path]
+    },
+    listFiles: (dir) => {
+      const prefix = dir.endsWith('/') ? dir : dir + '/'
+      return Object.keys(files).filter(p => p.startsWith(prefix))
+    },
+  }
+}