Pipeline System

/**
 * Function signature for AutoRest pipeline plugins
 * Each plugin receives configuration, input data, and output sink
 * @param config - AutoRest context with configuration and utilities
 * @param input - Input data source from previous pipeline stage
 * @param sink - Output data sink for transformed results
 * @returns Promise resolving to transformed data source
 */
type PipelinePlugin = (
  config: AutorestContext,
  input: DataSource,
  sink: DataSink
) => Promise<DataSource>;

/**
 * Definition of a pipeline plugin with metadata
 * Used for plugin registration and management
 */
interface PipelinePluginDefinition {
  /** Unique name identifying the plugin */
  readonly name: string;
  
  /** The plugin function implementation */
  readonly plugin: PipelinePlugin;
  
  /** Extension that provides this plugin (undefined for built-in) */
  readonly extension: AutoRestExtension | undefined;
  
  /** Whether this plugin is built into AutoRest Core */
  readonly builtIn: boolean;
}

import { PipelinePlugin, AutorestContext } from "@autorest/core";

// Custom validation plugin
const customValidationPlugin: PipelinePlugin = async (config, input, sink) => {
  console.log(`Running custom validation for ${config.pluginName}`);
  
  // Process each document in the input
  const documents = await input.ReadAll();
  
  for (const doc of documents) {
    const content = await doc.ReadAll();
    
    // Perform custom validation
    if (content.includes("deprecated")) {
      config.logger.warn("Document contains deprecated elements");
    }
    
    // Pass document through to output
    await sink.WriteData(doc.key, content, doc.identity, doc.artifactType);
  }
  
  return sink;
};

// Register the plugin
const pluginDefinition: PipelinePluginDefinition = {
  name: "custom-validator",
  plugin: customValidationPlugin,
  extension: undefined, // Built-in plugin
  builtIn: true
};

/**
 * Execute the complete AutoRest processing pipeline
 * Orchestrates all configured plugins in the correct order
 * @param configView - AutoRest context with configuration
 * @param fileSystem - File system interface for I/O operations
 */
async function runPipeline(
  configView: AutorestContext, 
  fileSystem: IFileSystem
): Promise<void>;

/**
 * Load all available plugins (built-in and extensions)
 * Discovers and initializes plugins based on configuration
 * @param context - AutoRest context for plugin discovery
 * @returns Promise resolving to map of plugin name to definition
 */
async function loadPlugins(
  context: AutorestContext
): Promise<{ [pluginName: string]: PipelinePluginDefinition }>;

/**
 * Create a per-file processing plugin from a file processor
 * Utility for creating plugins that process individual files
 * @param processorBuilder - Function that builds file processor
 * @returns Pipeline plugin that processes each file individually
 */
function createPerFilePlugin(
  processorBuilder: (config: AutorestContext) => Promise<(input: DataHandle, sink: DataSink) => Promise<DataHandle>>
): PipelinePlugin;

import { runPipeline, loadPlugins, AutoRest } from "@autorest/core";
import { RealFileSystem } from "@azure-tools/datastore";

async function executeFullPipeline() {
  const autorest = new AutoRest(console.log);
  
  // Configure for C# generation
  autorest.AddConfiguration({
    "input-file": "swagger.json",
    "output-folder": "./generated",
    "csharp": {
      "namespace": "MyClient"
    }
  });
  
  const context = await autorest.view;
  const fileSystem = new RealFileSystem();
  
  // Load all available plugins
  const plugins = await loadPlugins(context);
  console.log(`Loaded ${Object.keys(plugins).length} plugins`);
  
  // Execute the complete pipeline
  await runPipeline(context, fileSystem);
  console.log("Pipeline execution completed");
}

/**
 * Map of all built-in core plugins
 * Contains 40+ plugins for various processing stages
 */
const CORE_PLUGIN_MAP: { [pluginName: string]: PipelinePluginDefinition };

import { loadPlugins } from "@autorest/core";

async function inspectPlugins(context: AutorestContext) {
  const plugins = await loadPlugins(context);
  
  // List validation plugins
  const validationPlugins = Object.entries(plugins)
    .filter(([name]) => name.includes('validator'))
    .map(([name, def]) => ({
      name,
      builtIn: def.builtIn,
      extension: def.extension?.name
    }));
    
  console.log("Validation plugins:", validationPlugins);
  
  // List transformation plugins
  const transformPlugins = Object.entries(plugins)
    .filter(([name]) => name.includes('transform'))
    .map(([name, def]) => ({ name, builtIn: def.builtIn }));
    
  console.log("Transform plugins:", transformPlugins);
}

// Enable specific plugins
autorest.AddConfiguration({
  "input-file": "swagger.json",
  "use-extension": ["@autorest/csharp"],
  "pipeline": {
    // Customize plugin execution order
    "swagger-document/transform": [
      "schema-validator-swagger", 
      "semantic-validator",
      "openapi-document-converter"
    ]
  }
});

// Configure plugin-specific settings  
autorest.AddConfiguration({
  "schema-validator": {
    "strict-mode": true
  },
  "tree-shaker": {
    "preserve-unused": false
  }
});

import { AutoRest, PipelinePluginDefinition } from "@autorest/core";

// Define custom plugin
const myCustomPlugin: PipelinePluginDefinition = {
  name: "my-custom-processor",
  plugin: async (config, input, sink) => {
    // Custom processing logic
    const docs = await input.ReadAll();
    
    for (const doc of docs) {
      let content = await doc.ReadAll();
      
      // Apply custom transformations
      content = content.replace(/oldPattern/g, 'newPattern');
      
      await sink.WriteData(doc.key, content, doc.identity);
    }
    
    return sink;
  },
  extension: undefined,
  builtIn: false
};

// Register and use custom plugin
autorest.AddConfiguration({
  "input-file": "swagger.json",
  "pipeline": {
    "swagger-document/transform": [
      "loader-swagger",
      "my-custom-processor", // Custom plugin in pipeline
      "schema-validator-swagger"
    ]
  }
});