simple<T>(producer: (() => T | Promise<T>) | T): SimpleAdapter<T>

// Static value
.id('hello-route')
.from(simple('Hello, World!'))

// Array of values (each becomes a separate exchange)
.id('items-route')
.from(simple(['item1', 'item2', 'item3']))

// Dynamic function
.id('api-route')
.from(simple(async () => {
  const response = await fetch('https://api.example.com/data')
  return response.json()
}))

// With custom ID
.id('data-loader')
.from(simple(() => loadData()))

log<T>(formatter?: (exchange: Exchange<T>) => unknown): LogAdapter<T>

// Log final result (default: logs exchange ID, body, and headers)
.to(log())

// Log intermediate data without changing flow
.tap(log())

// Log with custom formatter function
.tap(log((ex) => `Exchange with id: ${ex.id}`))
.tap(log((ex) => `Body: ${JSON.stringify(ex.body)}`))
.tap(log((ex) => `Exchange with uuid: ${ex.headers.uuid}`))

timer(options?: TimerOptions): TimerAdapter

// Simple interval (every second)
.id('ticker')
.from(timer({ intervalMs: 1000 }))

// Limited runs (10 times, then stop)
.id('batch-job')
.from(timer({ intervalMs: 5000, repeatCount: 10 }))

// Start with delay
.id('delayed-start')
.from(timer({ intervalMs: 1000, delayMs: 5000 }))

// Daily at specific time
.id('daily-report')
.from(timer({ exactTime: '09:30:00' }))

// Fixed rate (ignore execution time)
.id('heartbeat')
.from(timer({ intervalMs: 1000, fixedRate: true }))

// Add random jitter to prevent synchronized execution
.id('distributed-task')
.from(timer({ intervalMs: 1000, jitterMs: 200 }))

direct<T>(endpoint: string | ((exchange: Exchange<T>) => string), options?: Partial<DirectAdapterOptions>): DirectAdapter<T>

// Producer route that sends to direct endpoint
craft()
  .id('data-producer')
  .from(source)
  .transform(processData)
  .to(direct('processed-data'))

// Consumer route that receives from direct endpoint
craft()
  .id('data-consumer')
  .from(direct('processed-data'))
  .process(businessLogic)
  .to(destination)

// HTTP API with direct routing
craft()
  .id('api-endpoint')
  .from(httpServer('/api/orders'))
  .to(direct('order-processing')) // Synchronous call

craft()
  .id('order-processor')
  .from(direct('order-processing'))
  .process(validateOrder)
  .process(saveOrder)
  .transform(() => ({ status: 'created', orderId: '12345' }))
  // Response goes back to HTTP client automatically

// Dynamic endpoint based on message content
craft()
  .id('dynamic-router')
  .from(source)
  .to(direct((ex) => `handler-${ex.body.type}`))

// Route messages to different handlers based on priority
craft()
  .id('priority-router')
  .from(source)
  .to(direct((ex) => {
    const priority = ex.headers['priority'] || 'normal';
    return `processing-${priority}`;
  }))

// Consumer routes (static endpoints required)
craft()
  .id('high-priority-handler')
  .from(direct('processing-high'))
  .to(urgentProcessor)

craft()
  .id('normal-priority-handler')
  .from(direct('processing-normal'))
  .to(standardProcessor)

fetch<T, R>(options: FetchOptions<T>): FetchAdapter<T, R>

// Static GET request as enricher
.enrich(fetch({ 
  method: 'GET',
  url: 'https://api.example.com/users'
}))

// Dynamic URL based on exchange data
.enrich(fetch({ 
  method: 'GET',
  url: (exchange) => `https://api.example.com/users/${exchange.body.userId}`
}))

// POST with body as destination
.to(fetch({
  method: 'POST',
  url: 'https://api.example.com/users',
  body: (exchange) => ({ name: exchange.body.name }),
  headers: { 'Content-Type': 'application/json' }
}))

// With query parameters
.enrich(fetch({
  url: 'https://api.example.com/search',
  query: (exchange) => ({ q: exchange.body.searchTerm, limit: 10 })
}))

.enrich(
  fetch({
    url: 'https://api.example.com/items'
  }),
  (original, enrichment) => ({
    ...original,
    body: {
      ...original.body,
      api: enrichment // place the full FetchResult on a field
    }
  })
)

// Or only keep the response body
.enrich(
  fetch({
    url: (exchange) => `https://api.example.com/users/${exchange.body.userId}`
  }),
  (original, enrichment) => ({
    ...original,
    body: {
      ...original.body,
      userData: enrichment.body
    }
  })
)

noop<T>(): NoopAdapter<T>

// Conditional destination based on environment
.to(process.env.NODE_ENV === 'production' ? realDestination() : noop())

// Testing placeholder
.to(noop()) // Messages are discarded but logged

file(options: FileOptions): FileAdapter

// Read file as source
.id('file-reader')
.from(file({ path: './input.txt', encoding: 'utf-8' }))

// Watch file for changes
.id('config-watcher')
.from(file({ path: './config.txt', watch: true }))

// Write to file
.to(file({ path: './output.txt', mode: 'write' }))

// Append to file
.to(file({ path: './log.txt', mode: 'append' }))

// Dynamic file paths
.to(file({ 
  path: (exchange) => `./data/${exchange.body.date}.txt`,
  mode: 'write',
  createDirs: true
}))

json(options: JsonOptions): JsonAdapter

// Read JSON file
.id('json-loader')
.from(json({ path: './data.json' }))

// Watch JSON file for changes
.id('config-watcher')
.from(json({ path: './config.json', watch: true }))

// Write JSON with formatting
.to(json({ 
  path: './output.json', 
  indent: 2,
  mode: 'write'
}))

// Dynamic JSON files
.to(json({ 
  path: (exchange) => `./exports/${exchange.body.id}.json`,
  mode: 'write'
}))

csv(options: CsvOptions): CsvAdapter

// Read CSV with headers
.id('csv-import')
.from(csv({ path: './data.csv', headers: true }))

// Read CSV without headers (array of arrays)
.id('raw-csv')
.from(csv({ path: './data.csv', headers: false }))

// Custom delimiter and encoding
.id('european-csv')
.from(csv({ 
  path: './data.csv', 
  delimiter: ';', 
  encoding: 'latin1',
  headers: true
}))

// Write CSV
.to(csv({ 
  path: './output.csv', 
  headers: ['name', 'email', 'age']
}))

// Dynamic CSV files
.to(csv({ 
  path: (exchange) => `./reports/${exchange.body.reportDate}.csv`,
  headers: true
}))

// Simple webhook endpoint
.id('webhook-receiver')
.from(http({ path: '/webhook', method: 'POST' }))

// Multiple methods on same path
.id('data-api')
.from(http({ path: '/api/data', method: ['GET', 'POST', 'PUT'] }))

smtp(options: SmtpOptions): SmtpAdapter

// Basic SMTP email
.to(smtp({
  host: 'smtp.gmail.com',
  port: 587,
  auth: { user: 'user@gmail.com', pass: 'password' },
  to: (exchange) => exchange.body.userEmail,
  subject: 'Welcome!',
  text: (exchange) => `Hello ${exchange.body.name}!`
}))

// HTML email with templates
.to(smtp({
  host: 'mail.company.com',
  port: 25,
  from: 'noreply@company.com',
  to: (exchange) => exchange.body.recipients,
  subject: (exchange) => `Order ${exchange.body.orderId} confirmed`,
  html: (exchange) => renderTemplate('order-confirmation', exchange.body)
}))

// With attachments
.to(smtp({
  host: 'smtp.company.com',
  auth: { user: process.env.SMTP_USER, pass: process.env.SMTP_PASS },
  to: 'admin@company.com',
  subject: 'Daily Report',
  text: 'Please find attached report.',
  attachments: (exchange) => [
    { filename: 'report.pdf', content: exchange.body.pdfBuffer }
  ]
}))

import { context, craft, simple } from '@routecraft/routecraft'

const destSpy = vi.fn()

const ctx = context()
  .routes(
    craft()
      .from(simple('test-data'))
      .to(destSpy)
  )
  .build()

await ctx.start()

// Standard Vitest assertions
expect(destSpy).toHaveBeenCalledTimes(1)
const sentExchange = destSpy.mock.calls[0][0]
expect(sentExchange.body).toBe('test-data')
expect(sentExchange.headers['x-test']).toBe('value')

const processorSpy = vi.fn((exchange) => {
  // Your processor logic here
  return exchange
})

const ctx = context()
  .routes(
    craft()
      .from(simple('input'))
      .process(processorSpy)
      .to(vi.fn())
  )
  .build()

await ctx.start()

expect(processorSpy).toHaveBeenCalled()

// Helper to get all received bodies
function getReceivedBodies(spy: any) {
  return spy.mock.calls.map(call => call[0].body)
}

// Helper to get all received headers
function getReceivedHeaders(spy: any, headerName: string) {
  return spy.mock.calls.map(call => call[0].headers[headerName])
}

const destSpy = vi.fn()
await ctx.start()

expect(getReceivedBodies(destSpy)).toEqual(['test-data'])
expect(getReceivedHeaders(destSpy, 'x-test')).toEqual(['value'])

import { Source, Destination, Processor } from '@routecraft/routecraft'

class MyAdapter implements Source<string> {
  readonly adapterId = 'my.custom.adapter'

  async subscribe(context, handler, abortController) {
    // Source implementation
    while (!abortController.signal.aborted) {
      await handler('data')
      await new Promise(resolve => setTimeout(resolve, 1000))
    }
  }
}

class MyDestination implements Destination<any> {
  readonly adapterId = 'my.destination.adapter'

  async send(exchange) {
    // Destination implementation
    console.log('Received:', exchange.body)
  }
}

// Extend StoreRegistry for type safety
declare module '@routecraft/routecraft' {
  interface StoreRegistry {
    'my.adapter.config': { apiKey: string }
    'my.adapter.cache': Map<string, any>
  }
}

class ConfigurableAdapter implements Destination<any> {
  readonly adapterId = 'configurable.adapter'

  async send(exchange) {
    const config = exchange.context.getStore('my.adapter.config')
    const cache = exchange.context.getStore('my.adapter.cache')
    
    // Use config and cache...
  }
}

import { MergedOptions } from '@routecraft/routecraft'

interface MyAdapterOptions {
  timeout: number
  retries: number
}

class MyAdapter implements Destination<any>, MergedOptions<MyAdapterOptions> {
  constructor(public options: Partial<MyAdapterOptions> = {}) {}

  mergedOptions(context): MyAdapterOptions {
    const globalOptions = context.getStore('my.adapter.global.options') || {}
    return {
      timeout: 5000,
      retries: 3,
      ...globalOptions,
      ...this.options
    }
  }

  async send(exchange) {
    const opts = this.mergedOptions(exchange.context)
    // Use merged options...
  }
}

// ✅ Prefer: DSL factory function
import { xyz } from '@acme/routecraft-xyz'

export default craft()
  .id('uses-xyz')
  .from(xyz({ /* options */ }))

// ❌ Avoid: direct class instantiation in routes
import { XyzAdapter } from '@acme/routecraft-xyz'

export default craft()
  .id('uses-xyz')
  .from(new XyzAdapter({ /* options */ }))