CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/npm-autorest--core

Core module for AutoRest that orchestrates OpenAPI code generation pipeline and provides extensible plugin architecture

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

SecuritybySnyk

Pending

The risk profile of this skill

Overview
Eval results
Files

index.mddocs/

AutoRest Core

AutoRest Core is the central orchestration engine for AutoRest, a tool that generates client libraries for accessing RESTful web services from OpenAPI specifications. It provides the complete pipeline infrastructure for processing OpenAPI/Swagger documents, managing extensions, and coordinating code generation across multiple target languages.

Package Information

  • Package Name: @autorest/core
  • Package Type: npm
  • Language: TypeScript
  • Installation: npm install @autorest/core

Core Imports

import { 
  AutoRest, 
  AutorestContext, 
  Message, 
  Channel, 
  Artifact,
  IdentifyDocument,
  IsOpenApiDocument,
  IsOpenApiExtension,
  IsConfigurationExtension,
  LiterateToJson,
  Shutdown,
  DocumentType,
  DocumentFormat,
  IFileSystem
} from "@autorest/core";

For CommonJS:

const { 
  AutoRest, 
  AutorestContext, 
  Message, 
  Channel, 
  Artifact,
  IdentifyDocument,
  IsOpenApiDocument,
  IsOpenApiExtension,
  IsConfigurationExtension,
  LiterateToJson,
  Shutdown,
  DocumentType,
  DocumentFormat,
  IFileSystem
} = require("@autorest/core");

Basic Usage

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

// Create AutoRest instance
const autorest = new AutoRest(
  (message) => console.log(message), // Logger sink
  new RealFileSystem()
);

// Add configuration
autorest.AddConfiguration({
  "input-file": "path/to/swagger.json",
  "output-folder": "./generated",
  "csharp": {}
});

// Process the OpenAPI specification
const result = autorest.Process();

// Wait for completion
const success = await result.finish;
console.log("Generation complete:", success);

Architecture

AutoRest Core is built around several key architectural components:

  • Processing Pipeline: Extensible plugin-based architecture with 40+ built-in plugins
  • Configuration System: Hierarchical configuration management with extension support
  • Message System: Structured logging and communication between pipeline stages
  • Document Processing: OpenAPI/Swagger document parsing, validation, and transformation
  • Extension Management: Dynamic loading and execution of language generators and transformers
  • Event System: Comprehensive event emission for progress tracking and artifact handling

CLI Tools

AutoRest Core provides two command-line interfaces:

  • autorest-core: Main CLI for running code generation
  • autorest-language-service: Language server for IDE integration

Capabilities

Core Processing Engine

Central AutoRest class that orchestrates the entire code generation pipeline, handling configuration management and plugin execution.

class AutoRest extends EventEmitter {
  constructor(
    loggerSink: LoggerSink,
    fileSystem?: IFileSystem,
    configFileOrFolderUri?: string
  );
  
  AddConfiguration(configuration: any): void;
  ResetConfiguration(): Promise<void>;
  Process(): { finish: Promise<boolean | Error>; cancel(): void };
  RegenerateView(includeDefault?: boolean): Promise<AutorestContext>;
  Invalidate(): void;
  
  readonly view: Promise<AutorestContext>;
}

type LoggerSink = (message: Message) => void;

Core Processing Engine

Message System

Comprehensive messaging system for structured communication between pipeline components, with typed message channels and source location tracking.

enum Channel {
  Information = "information",
  Warning = "warning", 
  Error = "error",
  Debug = "debug",
  Verbose = "verbose",
  Fatal = "fatal",
  Hint = "hint",
  File = "file",
  Configuration = "configuration",
  Protect = "protect",
  Control = "Control"
}

interface Message {
  Channel: Channel;
  Key?: Iterable<string>;
  Details?: any;
  Text: string;
  Source?: Array<SourceLocation>;
  Plugin?: string;
  FormattedMessage?: string;
}

Message System

Document Processing

OpenAPI and Swagger document identification, parsing, and type detection with support for multiple document formats.

enum DocumentType {
  OpenAPI2 = "OpenAPI2",
  OpenAPI3 = "OpenAPI3",
  LiterateConfiguration = "LiterateConfiguration", 
  Unknown = "Unknown"
}

async function IdentifyDocument(content: string): Promise<DocumentType>;
async function IsOpenApiDocument(content: string): Promise<boolean>;
async function IsOpenApiExtension(extension: string): Promise<boolean>;
async function IsConfigurationExtension(extension: string): Promise<boolean>;
async function LiterateToJson(content: string): Promise<string>;

Document Processing

Pipeline System

Extensible plugin architecture with built-in plugins for common operations like validation, transformation, and code generation.

type PipelinePlugin = (
  config: AutorestContext,
  input: DataSource,
  sink: DataSink
) => Promise<DataSource>;

interface PipelinePluginDefinition {
  readonly name: string;
  readonly plugin: PipelinePlugin;
  readonly extension: AutoRestExtension | undefined;
  readonly builtIn: boolean;
}

async function runPipeline(configView: AutorestContext, fileSystem: IFileSystem): Promise<void>;
async function loadPlugins(context: AutorestContext): Promise<{ [pluginName: string]: PipelinePluginDefinition }>;

Pipeline System

Configuration Management

Context-aware configuration system with hierarchical merging, extension support, and nested configuration scoping.

class AutorestContext {
  constructor(
    config: AutorestConfiguration,
    fileSystem: CachingFileSystem,
    messageEmitter: MessageEmitter,
    logger: AutorestLogger,
    stats: StatsCollector,
    plugin?: PipelinePluginDefinition
  );
  
  GetEntry(key: string): any;
  IsOutputArtifactRequested(artifact: string): boolean;
  getNestedConfiguration(scope: string, plugin?: PipelinePluginDefinition): Iterable<AutorestContext>;
  extendWith(...overrides: AutorestNormalizedConfiguration[]): AutorestContext;
  updateConfigurationFile(filename: string, content: string): void;
  resolveDirectives(predicate?: (each: ResolvedDirective) => boolean): void;
  
  readonly config: AutorestConfiguration;
  readonly fileSystem: CachingFileSystem;
  readonly logger: AutorestLogger;
  readonly pluginName: string;
}

Configuration Management

Types

Core Types

interface Artifact {
  uri: string;
  type: string;
  content: string;
}

interface SourceLocation {
  document: string;
  Position: EnhancedPosition;
}

interface ArtifactMessage extends Message {
  Details: Artifact & { sourceMap?: Array<Mapping> | RawSourceMap };
}

enum DocumentFormat {
  Markdown = "markdown",
  Yaml = "yaml", 
  Json = "json",
  Unknown = "unknown"
}

Global Utilities

/**
 * Shut down active AutoRest extension processes
 * Call this when your application is terminating to clean up resources
 */
async function Shutdown(): Promise<void>;

File System Interface

interface IFileSystem {
  // Re-exported from @azure-tools/datastore
  // Full interface available in that package
}

docs

configuration-management.md

core-engine.md

document-processing.md

index.md

message-system.md

pipeline-system.md

tile.json