Farrow Pipeline

import { createPipeline, defineMiddleware, composePipeline } from 'farrow-pipeline';

// Define a simple logging middleware that enriches the output
const loggerMiddleware = defineMiddleware<{ name: string }, { name: string, loggedAt: number }>((input, next) => {
  console.log(`[Logger] Processing input for: ${input.name}`);
  const result = next(input);
  return { ...result, loggedAt: Date.now() };
});

// Define a validation middleware for the name property
const validatorMiddleware = defineMiddleware<{ name: string }, { name: string }>((input, next) => {
  if (!input.name || input.name.length < 3) {
    throw new Error('Validation Error: Name must be at least 3 characters long.');
  }
  console.log(`[Validator] Input name "${input.name}" is valid.`);
  return next(input);
});

// Define a data processing middleware that transforms the data
const dataProcessorMiddleware = defineMiddleware<{ name: string, data?: any }, { processedData: string }>((input, next) => {
  console.log(`[Processor] Handling data for: ${input.name}`);
  const processed = `Transformed data for ${input.name} at ${new Date().toISOString()}`;
  const nextResult = next(input);
  return { ...nextResult, processedData: processed };
});

// Create a pipeline composed of these synchronous middlewares
const myPipeline = createPipeline()
  .use(loggerMiddleware)
  .use(validatorMiddleware)
  .use(dataProcessorMiddleware);

// Define an asynchronous middleware for demonstration purposes
const asyncMiddleware = defineMiddleware<{ id: number }, { id: number, fetchedData: string }>(async (input, next) => {
  console.log(`[Async] Starting async operation for ID: ${input.id}`);
  await new Promise(resolve => setTimeout(resolve, 100)); // Simulate async work
  const fetchedData = `Data for item ${input.id} from external API`;
  console.log(`[Async] Finished async operation for ID: ${input.id}`);
  const result = await next(input); // Await the result of the next middleware
  return { ...result, fetchedData };
});

// Compose multiple middlewares (including async ones) into a single pipeline
const complexPipeline = composePipeline(
  asyncMiddleware,
  defineMiddleware<{ id: number, fetchedData?: string }, { finalResult: string }>(async (input) => {
    console.log(`[Final] Processing final stage for ID: ${input.id} with fetched data: ${input.fetchedData}`);
    return { finalResult: `Final output for ID ${input.id} based on: ${input.fetchedData}` };
  })
);

// Run the pipelines
async function runExamples() {
  try {
    console.log('\n--- Running Simple Pipeline (Valid Input) ---');
    const result1 = await myPipeline.run({ name: 'Alice' });
    console.log('Pipeline Result 1:', result1);
    // Expected: { name: 'Alice', loggedAt: <timestamp>, processedData: 'Transformed data for Alice...' }

    console.log('\n--- Running Simple Pipeline (Invalid Input) ---');
    try {
      await myPipeline.run({ name: 'Bo' }); // This should throw due to validation
    } catch (error: any) {
      console.error('Pipeline Error:', error.message);
      // Expected: 'Validation Error: Name must be at least 3 characters long.'
    }

    console.log('\n--- Running Complex Pipeline ---');
    const result2 = await complexPipeline.run({ id: 123 });
    console.log('Complex Pipeline Result 2:', result2);
    // Expected: { id: 123, fetchedData: 'Data for item 123 from external API', finalResult: 'Final output for ID 123...' }

  } catch (e: any) {
    console.error("An unexpected error occurred during example execution:", e.message);
  }
}

runExamples();