@orsetra/camel-pom-gen 1.0.0

package/index.ts

@@ -0,0 +1,232 @@
+/**
+ * @orsetra/camel-pom-gen
+ *
+ * Generate or sync a Camel K pom.xml by scanning a project's source tree.
+ *
+ * Usage
+ * ─────
+ *   import { init, syncPom, nodeFsProvider } from '@orsetra/camel-pom-gen'
+ *   import fs from 'fs'
+ *   import path from 'path'
+ *
+ *   // Once at IDE startup:
+ *   init({
+ *     operatorVersion: '2.11.0',
+ *     flavor: 'plain-quarkus',
+ *     fs: nodeFsProvider(fs, path),
+ *     rootDir: '/workspace/my-integration',  // default: '.'
+ *   })
+ *
+ *   // On every route change:
+ *   const { pom, resolvedDeps, warnings } = await syncPom()
+ *   // → writes pom.xml if caller wants: fs.writeFileSync('pom.xml', pom)
+ *
+ * Source scanning (Maven conventions)
+ * ────────────────────────────────────
+ *   src/main/resources/  → YAML (.yaml/.yml), XML, Groovy, JS, KTS routes
+ *   src/main/java/       → Java DSL sources
+ *
+ * Sync behavior
+ * ─────────────
+ *   pom.xml absent  → generate from bundled template
+ *   pom.xml present → update <dependencies> only; everything the developer
+ *                     added manually (extra deps, repos, profiles…) is preserved
+ */
+
+import { getFsProvider, registerFsProvider } from './src/fs-provider'
+import { inspect } from './src/inspector/index'
+import { manageIntegrationDependencies, createProject, addDependencyGAV } from './src/dependencies/manager'
+import { getDefaultTemplate, renderTemplate, buildTokens } from './src/generator/template'
+import { getBundledCatalog } from './src/catalogs/index'
+import { getRuntimeConfig, DEFAULT_CONFIG } from './src/config'
+import type { RuntimeFlavor, CamelKRuntimeConfig } from './src/config'
+import type { FileSystemProvider } from './src/fs-provider'
+import type { SourceLanguage } from './src/inspector/types'
+
+// ── Public types ──────────────────────────────────────────────────────────────
+
+export type { RuntimeFlavor, CamelKRuntimeConfig } from './src/config'
+export type { FileSystemProvider } from './src/fs-provider'
+export type { SourceLanguage } from './src/inspector/types'
+
+export interface PomGenConfig {
+  /** Camel K operator version, e.g. "2.11.0". Defaults to latest known. */
+  operatorVersion?: string
+  /** Runtime flavor. Derived from operatorVersion when omitted. */
+  flavor?: RuntimeFlavor
+  /** FileSystem provider — how the package reads and lists project files. */
+  fs: FileSystemProvider
+  /**
+   * Project root directory. Defaults to '.'.
+   * The package looks for sources under {rootDir}/src/main/resources/ and
+   * {rootDir}/src/main/java/.
+   * The pom.xml is read from and written back to {rootDir}/pom.xml.
+   */
+  rootDir?: string
+}
+
+export interface SyncPomResult {
+  /** Generated or updated pom.xml content. */
+  pom: string
+  /** Resolved Maven coordinates of all detected Camel dependencies. */
+  resolvedDeps: string[]
+  /** Source URIs that could not be matched to a catalog artifact. */
+  warnings: string[]
+}
+
+// ── Global state ──────────────────────────────────────────────────────────────
+
+let _config: CamelKRuntimeConfig = DEFAULT_CONFIG
+let _rootDir = '.'
+
+// ── Init ──────────────────────────────────────────────────────────────────────
+
+/**
+ * Initialize the package. Call once at IDE startup before syncPom().
+ */
+export function init(config: PomGenConfig): void {
+  const base = getRuntimeConfig(config.operatorVersion ?? DEFAULT_CONFIG.operatorVersion)
+  _config  = config.flavor && config.flavor !== base.flavor
+    ? { ...base, flavor: config.flavor }
+    : base
+  _rootDir = config.rootDir ?? '.'
+  registerFsProvider(config.fs)
+}
+
+// ── syncPom ───────────────────────────────────────────────────────────────────
+
+/**
+ * Scan the project sources, then generate or update pom.xml.
+ * Must call init() first.
+ */
+export async function syncPom(): Promise<SyncPomResult> {
+  const fs      = getFsProvider()
+  const catalog = getBundledCatalog(_config.catalogVersion)
+  if (!catalog) throw new Error(
+    `[camel-pom-gen] No bundled catalog for version "${_config.catalogVersion}".`,
+  )
+
+  // Read existing pom.xml (undefined on first run)
+  const existingPom = await safeRead(fs, join(_rootDir, 'pom.xml'))
+
+  // Scan source directories
+  const sources = await scanSources(fs, _rootDir)
+
+  // Build dependency project
+  const project = createProject('org.apache.camel.k.integration', 'camel-k-integration', _config.operatorVersion)
+  if (_config.flavor === 'quarkus') {
+    addDependencyGAV(project, 'org.apache.camel.k', 'camel-k-runtime')
+  }
+
+  const allDeps = new Set<string>()
+
+  // Inspect each source file
+  for (const { name, content, language } of sources) {
+    const lang = language ?? inferLanguage(name)
+    if (!lang) continue
+    for (const dep of inspect(catalog, content, lang).dependencies) allDeps.add(dep)
+  }
+
+  // Preserve deps the developer added manually in the existing pom
+  if (existingPom) {
+    for (const dep of extractManualDeps(existingPom)) allDeps.add(dep)
+  }
+
+  const warnings = manageIntegrationDependencies(project, catalog, [...allDeps])
+  const pom = renderTemplate(getDefaultTemplate(_config.flavor), buildTokens(_config), project)
+
+  return {
+    pom,
+    resolvedDeps: project.dependencies.map(d => `${d.groupId}:${d.artifactId}`),
+    warnings,
+  }
+}
+
+// ── Source scanning ───────────────────────────────────────────────────────────
+
+const ROUTE_EXTS  = new Set(['.yaml', '.yml', '.xml', '.groovy', '.js', '.kts'])
+const JAVA_EXT    = '.java'
+
+interface ScannedFile { name: string; content: string; language?: SourceLanguage }
+
+async function scanSources(fs: FileSystemProvider, rootDir: string): Promise<ScannedFile[]> {
+  const resourcesDir = join(rootDir, 'src/main/resources')
+  const javaDir      = join(rootDir, 'src/main/java')
+
+  const [resourceFiles, javaFiles] = await Promise.all([
+    Promise.resolve(fs.listFiles(resourcesDir)).catch(() => [] as string[]),
+    Promise.resolve(fs.listFiles(javaDir)).catch(()      => [] as string[]),
+  ])
+
+  const results: ScannedFile[] = []
+
+  for (const path of resourceFiles) {
+    if (!ROUTE_EXTS.has(ext(path))) continue
+    const content = await safeRead(fs, path)
+    if (content !== undefined) results.push({ name: path, content })
+  }
+
+  for (const path of javaFiles) {
+    if (!path.endsWith(JAVA_EXT)) continue
+    const content = await safeRead(fs, path)
+    if (content !== undefined) results.push({ name: path, content })
+  }
+
+  return results
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+/** Safely read a file — catches both synchronous throws and rejected Promises. */
+async function safeRead(fs: FileSystemProvider, path: string): Promise<string | undefined> {
+  try {
+    return await Promise.resolve(fs.readFile(path))
+  } catch {
+    return undefined
+  }
+}
+
+function join(...parts: string[]): string {
+  const result = parts
+    .filter(p => p !== '' && p !== '.')
+    .join('/')
+    .replace(/\/+/g, '/')
+    .replace(/\/$/, '')
+  return result || '.'
+}
+
+function ext(filename: string): string {
+  const i = filename.lastIndexOf('.')
+  return i >= 0 ? filename.slice(i) : ''
+}
+
+function inferLanguage(filename: string): SourceLanguage | undefined {
+  if (filename.endsWith('.java'))                               return 'java'
+  if (filename.endsWith('.yaml') || filename.endsWith('.yml')) return 'yaml'
+  if (filename.endsWith('.xml'))                                return 'xml'
+  if (filename.endsWith('.groovy'))                             return 'groovy'
+  if (filename.endsWith('.js'))                                 return 'js'
+  if (filename.endsWith('.kts'))                                return 'kts'
+  return undefined
+}
+
+function extractManualDeps(pom: string): string[] {
+  const RE = /<dependency>\s*<groupId>([^<]+)<\/groupId>\s*<artifactId>([^<]+)<\/artifactId>(?:\s*<version>([^<]+)<\/version>)?/g
+  const managed = /^(org\.apache\.camel|io\.quarkus)/
+  const result: string[] = []
+  let m: RegExpExecArray | null
+  while ((m = RE.exec(pom)) !== null) {
+    const [, g, a, v] = m
+    if (!managed.test(g)) result.push(`mvn:${g}:${a}${v ? ':' + v : ''}`)
+  }
+  return result
+}
+
+// ── Advanced / low-level exports ──────────────────────────────────────────────
+
+export { nodeFsProvider, memFsProvider } from './src/fs-provider'
+export { getRuntimeConfig, DEFAULT_CONFIG, OPERATOR_RUNTIME_CONFIGS } from './src/config'
+export { parseCatalogYaml } from './src/catalog/catalog'
+export type { CamelCatalog } from './src/catalog/types'
+export { getBundledCatalog, BUNDLED_CATALOG_VERSIONS } from './src/catalogs/index'
+export { serializePom } from './src/generator/pom'

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@orsetra/camel-pom-gen",
+  "version": "1.0.0",
+  "description": "Generate Camel K pom.xml from route sources — ports the dependency-detection pipeline from camel-k Go to TypeScript",
+  "main": "./index.ts",
+  "types": "./index.ts",
+  "exports": {
+    ".": "./index.ts"
+  },
+  "files": [
+    "index.ts",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/orsetra/console-ui.git",
+    "directory": "packages/camel-pom-gen"
+  },
+  "keywords": [
+    "camel",
+    "camel-k",
+    "pom",
+    "maven",
+    "dependency",
+    "orsetra"
+  ],
+  "dependencies": {
+    "js-yaml": "^4.1.1"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "typescript": "^5",
+    "vitest": "^5.0.3"
+  }
+}

package/src/catalog/catalog.ts

@@ -0,0 +1,81 @@
+import yaml from 'js-yaml'
+import type { CamelCatalog, CamelArtifact } from './types'
+
+interface RawCatalog {
+  spec: {
+    runtime: CamelCatalog['runtime']
+    artifacts: CamelCatalog['artifacts']
+    loaders: CamelCatalog['loaders']
+  }
+}
+
+/** Parse a CamelCatalog from YAML string content. */
+export function parseCatalogYaml(content: string): CamelCatalog {
+  const raw = yaml.load(content) as RawCatalog
+  if (!raw?.spec) throw new Error('Invalid CamelCatalog YAML: missing spec')
+  return {
+    runtime: raw.spec.runtime ?? { version: '', provider: '', metadata: {}, dependencies: [], capabilities: {} },
+    artifacts: raw.spec.artifacts ?? {},
+    loaders: raw.spec.loaders ?? {},
+  }
+}
+
+/** Find the first artifact that exposes the given URI scheme. */
+export function getArtifactByScheme(catalog: CamelCatalog, schemeId: string): CamelArtifact | undefined {
+  for (const artifact of Object.values(catalog.artifacts)) {
+    if (artifact.schemes?.some(s => s.id === schemeId)) return artifact
+  }
+  return undefined
+}
+
+/** Find the first artifact that provides the given data format. */
+export function getArtifactByDataFormat(catalog: CamelCatalog, dfId: string): CamelArtifact | undefined {
+  for (const artifact of Object.values(catalog.artifacts)) {
+    if (artifact.dataformats?.includes(dfId)) return artifact
+  }
+  return undefined
+}
+
+/** Decode a URI like "timer:tick?period=5000" → schemeId "timer" → artifact. */
+export function decodeComponent(catalog: CamelCatalog, uri: string): CamelArtifact | undefined {
+  const schemeId = getURIScheme(uri)
+  if (!schemeId) return undefined
+  return getArtifactByScheme(catalog, schemeId)
+}
+
+/** Return the Maven dependency ID string for an artifact: "mvn:groupId:artifactId". */
+export function getDependencyID(artifact: CamelArtifact): string {
+  return `mvn:${artifact.groupId}:${artifact.artifactId}`
+}
+
+/**
+ * Resolve the dependency ID for a DSL loader language.
+ * Returns `mvn:groupId:artifactId` or undefined if not found.
+ */
+export function getLanguageDependency(catalog: CamelCatalog, language: string): string | undefined {
+  const loader = catalog.loaders[language]
+  if (loader) return `mvn:${loader.groupId}:${loader.artifactId}`
+  return undefined
+}
+
+/** Check whether a URI is resolvable (not a property placeholder). */
+export function isResolvable(uri: string): boolean {
+  return !uri.includes('{{') && !uri.includes('${')
+}
+
+export function getURIScheme(uri: string): string {
+  const idx = uri.indexOf(':')
+  return idx > 0 ? uri.substring(0, idx) : ''
+}
+
+/** Check if the scheme is HTTP-based. */
+export function isHTTPScheme(catalog: CamelCatalog, schemeId: string): boolean {
+  const artifact = getArtifactByScheme(catalog, schemeId)
+  return artifact?.schemes?.find(s => s.id === schemeId)?.http ?? false
+}
+
+/** Check if the scheme is passive. */
+export function isPassiveScheme(catalog: CamelCatalog, schemeId: string): boolean {
+  const artifact = getArtifactByScheme(catalog, schemeId)
+  return artifact?.schemes?.find(s => s.id === schemeId)?.passive ?? false
+}

package/src/catalog/types.ts

@@ -0,0 +1,66 @@
+export interface CamelScheme {
+  id: string
+  http: boolean
+  passive: boolean
+}
+
+export interface CamelArtifactDep {
+  groupId: string
+  artifactId: string
+  type?: string
+  classifier?: string
+}
+
+export interface CamelArtifactExclusion {
+  groupId: string
+  artifactId: string
+}
+
+export interface CamelArtifact {
+  groupId: string
+  artifactId: string
+  schemes?: CamelScheme[]
+  /** Data format names this artifact provides (e.g. ["avro"]) */
+  dataformats?: string[]
+  /** Fully-qualified Java class names provided by this artifact */
+  javaTypes?: string[]
+  dependencies?: CamelArtifactDep[]
+  exclusions?: CamelArtifactExclusion[]
+}
+
+export interface CamelLoader {
+  groupId: string
+  artifactId: string
+  /** Language identifiers supported by this DSL loader */
+  languages?: string[]
+  metadata?: Record<string, string>
+}
+
+export interface CamelCapabilityDep {
+  groupId: string
+  artifactId: string
+  classifier?: string
+}
+
+export interface CamelCapability {
+  dependencies: CamelCapabilityDep[]
+  metadata?: Record<string, string>
+  runtimeProperties?: { key: string; value: string }[]
+}
+
+export interface CamelRuntime {
+  version: string
+  provider: string
+  applicationClass?: string
+  metadata: Record<string, string>
+  dependencies: CamelCapabilityDep[]
+  capabilities: Record<string, CamelCapability>
+}
+
+export interface CamelCatalog {
+  runtime: CamelRuntime
+  /** Keyed by artifactId */
+  artifacts: Record<string, CamelArtifact>
+  /** Keyed by language name (yaml, java, xml, groovy, js, kts) */
+  loaders: Record<string, CamelLoader>
+}