or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

autorest-generator.mdconfiguration.mddocument-processing.mdfile-system.mdindex.mdmessaging.md
tile.json

tessl/npm-microsoft-azure--autorest-core

AutoRest core module that generates client libraries for accessing RESTful web services from OpenAPI specifications.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/@microsoft.azure/autorest-core@2.0.x

To install, run

npx @tessl/cli install tessl/npm-microsoft-azure--autorest-core@2.0.0

index.mddocs/

AutoRest Core

AutoRest Core is the foundational module of the AutoRest code generation tool, which generates client libraries for accessing RESTful web services from OpenAPI specifications. This package provides the core functionality for parsing, validating, and transforming OpenAPI specs into code generation artifacts, serving as the central processing engine that coordinates with language-specific generators.

Package Information

  • Package Name: @microsoft.azure/autorest-core
  • Package Type: npm
  • Language: TypeScript
  • Installation: npm install @microsoft.azure/autorest-core

Core Imports

import { 
  AutoRest, 
  ConfigurationView, 
  IFileSystem, 
  Message, 
  Channel, 
  Artifact,
  IdentifyDocument,
  LiterateToJson,
  IsConfigurationDocument,
  IsOpenApiDocument,
  IsConfigurationExtension,
  IsOpenApiExtension,
  DocumentType,
  DocumentFormat,
  DocumentExtension,
  DocumentPatterns
} from "@microsoft.azure/autorest-core";

// File system implementations (not re-exported from main, import directly)
import { RealFileSystem, MemoryFileSystem, EnhancedFileSystem } from "@microsoft.azure/autorest-core/lib/file-system";

For CommonJS:

const { 
  AutoRest, 
  ConfigurationView, 
  IFileSystem, 
  Message, 
  Channel, 
  Artifact 
} = require("@microsoft.azure/autorest-core");

Basic Usage

import { AutoRest } from "@microsoft.azure/autorest-core";
import { RealFileSystem } from "@microsoft.azure/autorest-core/lib/file-system";

// Create AutoRest instance with file system
const autorest = new AutoRest(new RealFileSystem(), "./autorest-config.json");

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

// Listen to events  
const unsubscribeGenerated = autorest.GeneratedFile.Subscribe((autorest, artifact) => {
  console.log(`Generated: ${artifact.uri}`);
});

const unsubscribeMessage = autorest.Message.Subscribe((autorest, message) => {
  console.log(`${message.Channel}: ${message.Text}`);
});

// Start processing
const { finish, cancel } = autorest.Process();
const result = await finish;

Architecture

AutoRest Core is built around several key components:

  • AutoRest Class: Main generator instance that orchestrates the entire process
  • File System Abstraction: Pluggable file system implementations (Real, Memory, Enhanced)
  • Configuration System: Hierarchical configuration loading and management
  • Message System: Event-driven communication with detailed logging and error reporting
  • Pipeline System: Extensible processing pipeline with plugin support
  • Document Processing: OpenAPI and configuration document identification and parsing
  • Type System: Complete TypeScript integration with full type definitions

Capabilities

AutoRest Generator

Main generator class that coordinates the entire code generation process with event-driven architecture and configuration management.

class AutoRest {
  constructor(fileSystem?: IFileSystem, configFileOrFolderUri?: string);
  view: Promise<ConfigurationView>;
  AddConfiguration(configuration: any): void;
  ResetConfiguration(): Promise<void>;
  Process(): { finish: Promise<boolean | Error>, cancel: () => void };
  
  // Events
  Finished: IEvent<AutoRest, boolean | Error>;
  GeneratedFile: IEvent<AutoRest, Artifact>;
  ClearFolder: IEvent<AutoRest, string>;
  Message: IEvent<AutoRest, Message>;
}

AutoRest Generator

File System Operations

File system abstraction providing pluggable implementations for different environments, including real file system, in-memory operations, and GitHub integration.

interface IFileSystem {
  EnumerateFileUris(folderUri: string): Promise<Array<string>>;
  ReadFile(uri: string): Promise<string>;
}

class RealFileSystem implements IFileSystem {
  constructor();
  EnumerateFileUris(folderUri: string): Promise<string[]>;
  ReadFile(uri: string): Promise<string>;
  WriteFile(uri: string, content: string): Promise<void>;
}

class MemoryFileSystem implements IFileSystem {
  constructor(files: Map<string, string>);
  readonly Outputs: Map<string, string>;
  ReadFile(uri: string): Promise<string>;
  EnumerateFileUris(folderUri?: string): Promise<Array<string>>;
  WriteFile(uri: string, content: string): Promise<void>;
}

class EnhancedFileSystem implements IFileSystem {
  constructor(githubAuthToken?: string);
  EnumerateFileUris(folderUri: string): Promise<string[]>;
  ReadFile(uri: string): Promise<string>;
  WriteFile(uri: string, content: string): Promise<void>;
}

File System Operations

Document Processing

Document type identification and format detection for OpenAPI specifications and configuration files.

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

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

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

const DocumentExtension: {
  yaml: DocumentFormat.Yaml;
  yml: DocumentFormat.Yaml;
  json: DocumentFormat.Json;
  md: DocumentFormat.Markdown;
  markdown: DocumentFormat.Markdown;
};

const DocumentPatterns: {
  yaml: string[];
  json: string[];
  markdown: string[];
  all: string[];
};

Document Processing

Configuration Management

Hierarchical configuration system with support for multiple configuration sources and view-based access patterns.

class ConfigurationView {
  // Configuration access and management methods
}

interface AutoRestConfigurationImpl {
  // Core processing options
  "input-file"?: string | string[];
  "output-folder"?: string;
  "base-folder"?: string;
  
  // Processing flags
  "debug"?: boolean;
  "verbose"?: boolean;
  "message-format"?: string;
  
  // Plugin options
  "use-extension"?: string | string[];
  "require"?: string | string[];
  "directive"?: any[];
  
  // Language-specific options
  "namespace"?: string;
  "package-name"?: string;
}

Configuration Management

Message System

Event-driven messaging system with structured logging, error reporting, and multi-channel communication.

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

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

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

Message System

Binary Entry Points

The package provides two CLI tools:

  • autorest-core: Main CLI for processing OpenAPI specifications (dist/app.js)
  • autorest-language-service: Language service for editor integration (dist/language-service/language-service.js)

Types

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

interface Range {
  document: string;
  start: Position;
  end: Position;
}

interface Position {
  line: number;
  column: number;
}

interface IEvent<TSender, TArgs> {
  Subscribe(fn: (sender: TSender, args: TArgs) => void): () => void;
  Unsubscribe(fn: (sender: TSender, args: TArgs) => void): void;
  Dispatch(args: TArgs): void;
}