tessl/npm-autorest--system-requirements

System requirement validation and resolution for autorest.

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Core System Requirements Resolution

Name: tessl/npm-autorest--system-requirements
Author: tessl

Primary API for validating multiple system requirements and handling extension requirements with custom error messages. These functions provide the main entry points for system requirement validation.

Capabilities

Extension Requirements Validation

Validates extension requirements and returns only errors, filtering out successful resolutions for streamlined error handling.

/**
 * Resolve the extension requirements and returns a list of errors.
 * @param requirements - Map of requirements with optional custom error messages
 * @returns Array of errors for failed requirements (empty if all succeed)
 */
function validateExtensionSystemRequirements(
  requirements: ExtensionSystemRequirements
): Promise<SystemRequirementError[]>;

Usage Example:

import { validateExtensionSystemRequirements } from "@autorest/system-requirements";

const requirements = {
  python: { 
    version: ">=3.6", 
    message: "Python 3.6+ is required for code generation" 
  },
  java: { 
    version: ">=11",
    environmentVariable: "AUTOREST_JAVA_HOME"
  }
};

const errors = await validateExtensionSystemRequirements(requirements);
if (errors.length > 0) {
  errors.forEach(error => console.error(`${error.name}: ${error.message}`));
}

Multiple Requirements Resolution

Resolves multiple system requirements and returns both successful resolutions and errors, maintaining the structure of the input requirements.

/**
 * Validate the given commands are available in the path and check the version for known commands.
 * @param requirements - Map of requirement configurations
 * @returns Map of resolution or error with the key being the command names provided
 */
function resolveSystemRequirements<T extends { [name: string]: SystemRequirement }>(
  requirements: T
): Promise<SystemRequirementsResults<T>>;

Usage Example:

import { resolveSystemRequirements } from "@autorest/system-requirements";

const requirements = {
  python: { version: ">=3.6" },
  java: { version: ">=11" },
  node: {} // No version requirement
};

const results = await resolveSystemRequirements(requirements);

// Check individual results
if ("error" in results.python) {
  console.error("Python requirement failed:", results.python.message);
} else {
  console.log("Python resolved:", results.python.command);
}

Single Requirement Resolution

Resolves a single system requirement by name, delegating to specialized resolvers for known commands or using generic resolution.

/**
 * Validate the given command is available in the path and check the version for known commands.
 * @param name - Name of the command
 * @param requirement - Requirement configuration
 * @returns Resolution or error
 */
function resolveSystemRequirement(
  name: string,
  requirement: SystemRequirement
): Promise<SystemRequirementResolution | SystemRequirementError>;

Usage Example:

import { resolveSystemRequirement } from "@autorest/system-requirements";

const result = await resolveSystemRequirement("python", { 
  version: ">=3.8",
  environmentVariable: "PYTHON_PATH"
});

if ("error" in result) {
  console.error("Resolution failed:", result.message);
} else {
  console.log(`Resolved ${result.name} to: ${result.command}`);
  if (result.additionalArgs) {
    console.log("Additional args:", result.additionalArgs.join(" "));
  }
}

Core Types

interface SystemRequirement {
  /** Semantic version requirement (e.g., ">=3.6", "^11.0.0") */
  version?: string;
  /** Name of environment variable containing path to executable */
  environmentVariable?: string;
}

interface ExtensionSystemRequirement extends SystemRequirement {
  /** Custom error message for extension-specific context */
  message?: string;
}

interface ExtensionSystemRequirements {
  [name: string]: ExtensionSystemRequirement;
}

interface SystemRequirementResolution {
  /** Name of the requirement (e.g., "python", "java") */
  name: string;
  /** Command that was resolved (e.g., "python3", "/usr/bin/java") */
  command: string;
  /** Additional arguments needed for the command (e.g., ["-3"] for py.exe) */
  additionalArgs?: string[];
}

interface SystemRequirementError extends SystemRequirementResolution {
  error: true;
  /** Error message describing the failure */
  message: string;
  /** Required version that was not satisfied */
  neededVersion?: string;
  /** Actual version that was found */
  actualVersion?: string;
}

type SystemRequirementsResults<T> = {
  [key in keyof T]: SystemRequirementResolution | SystemRequirementError;
};