tessl/maven-org-openapitools--openapi-generator

OpenAPI Generator allows generation of API client libraries (SDK generation), server stubs, documentation and configuration automatically given an OpenAPI Spec

—

Pending

Overview

Eval results

Files

Core Generation

Name: tessl/maven-org-openapitools--openapi-generator
Author: tessl

The core generation system provides the fundamental interfaces and implementations for OpenAPI code generation. It defines contracts for customization and executes the generation workflow.

Core Interfaces

CodegenConfig Interface

The main interface that defines how code generation is configured and customized for specific languages and frameworks.

interface CodegenConfig {
    // Generator identification
    String getName();
    String getHelp();
    CodegenType getTag();
    GeneratorLanguage generatorLanguage();
    GeneratorMetadata getGeneratorMetadata();
    
    // Configuration properties
    Map<String, Object> additionalProperties();
    Map<String, String> serverVariableOverrides();
    Map<String, Object> vendorExtensions();
    List<CliOption> cliOptions();
    
    // Directory and package configuration
    String outputFolder();
    String templateDir();
    String embeddedTemplateDir();
    String apiPackage();
    String modelPackage();
    String apiFileFolder();
    String modelFileFolder();
    
    // Name transformation methods
    String toApiName(String name);
    String toModelName(String name);
    String toParamName(String name);
    String escapeText(String text);
    String escapeReservedWord(String name);
    String sanitizeName(String name);
    
    // Type handling
    String getTypeDeclaration(Schema schema);
    String getTypeDeclaration(String name);
    
    // Model and operation conversion
    CodegenModel fromModel(String name, Schema schema);
    CodegenOperation fromOperation(String resourcePath, String httpMethod, 
                                   Operation operation, List<Server> servers);
    
    // Processing lifecycle
    void processOpts();
    void preprocessOpenAPI(OpenAPI openAPI);
    void processOpenAPI(OpenAPI openAPI);
    
    // Post-processing
    Map<String, ModelsMap> postProcessAllModels(Map<String, ModelsMap> objs);
    OperationsMap postProcessOperationsWithModels(OperationsMap objs, List<ModelMap> allModels);
    
    // Template and file handling
    List<SupportingFile> supportingFiles();
    Map<String, String> apiTemplateFiles();
    Map<String, String> modelTemplateFiles();
    boolean shouldOverwrite(String filename);
    
    // Mapping configurations
    Map<String, String> typeMapping();
    Map<String, String> importMapping();
    Map<String, String> schemaMapping();
    Map<String, String> nameMapping();
    Set<String> reservedWords();
}

Generator Interface

Simple interface for executing the code generation process.

interface Generator {
    Generator opts(ClientOptInput opts);
    List<File> generate();
}

Default Implementations

DefaultCodegen Abstract Class

Base implementation providing common functionality for all code generators.

abstract class DefaultCodegen implements CodegenConfig {
    // Constructor
    public DefaultCodegen();
    
    // Configuration
    public List<CliOption> cliOptions();
    public void processOpts();
    public void setOpenAPI(OpenAPI openAPI);
    
    // Model processing
    public CodegenModel fromModel(String name, Schema schema);
    public Map<String, ModelsMap> postProcessAllModels(Map<String, ModelsMap> objs);
    public ModelsMap postProcessModels(ModelsMap objs);
    public Map<String, CodegenModel> getAllModels(Map<String, ModelsMap> objs);
    
    // Operation processing
    public CodegenOperation fromOperation(String resourcePath, String httpMethod, 
                                          Operation operation, List<Server> servers);
    public OperationsMap postProcessOperationsWithModels(OperationsMap objs, List<ModelMap> allModels);
    
    // Name transformation
    public String toModelName(String name);
    public String toApiName(String name);
    public String sanitizeName(String name);
    public String escapeText(String text);
    public String escapeReservedWord(String name);
    
    // Enum handling
    public String toEnumValue(String value, String datatype);
    public String toEnumVarName(String value, String datatype);
    public String toEnumDefaultValue(String value, String datatype);
    
    // Type handling
    public String getTypeDeclaration(Schema schema);
    public String getSchemaType(Schema schema);
    
    // Utilities
    public boolean specVersionGreaterThanOrEqualTo310(OpenAPI openAPI);
    public void postProcess();
}

DefaultGenerator Class

Default implementation of the Generator interface that orchestrates the generation process.

class DefaultGenerator implements Generator {
    // Constructors
    public DefaultGenerator();
    public DefaultGenerator(Boolean dryRun);
    
    // Core generation
    public Generator opts(ClientOptInput opts);
    public List<File> generate();
    
    // Processing methods
    public Map<String, List<CodegenOperation>> processPaths(Paths paths);
    public Map<String, List<CodegenOperation>> processWebhooks(Map<String, PathItem> webhooks);
    
    // Configuration
    public void setGenerateMetadata(Boolean generateMetadata);
    public void setGeneratorPropertyDefault(final String key, final String value);
}

Usage Examples

Creating a Custom Generator

// Extend DefaultCodegen for language-specific implementation
public class MyCustomGenerator extends DefaultCodegen implements CodegenConfig {
    
    public MyCustomGenerator() {
        super();
        
        // Configure language-specific settings
        outputFolder = "generated-code";
        modelTemplateFiles.put("model.mustache", ".java");
        apiTemplateFiles.put("api.mustache", ".java");
        
        // Set up type mappings
        typeMapping.put("integer", "Integer");
        typeMapping.put("long", "Long");
        typeMapping.put("string", "String");
    }
    
    @Override
    public String getName() {
        return "my-custom-generator";
    }
    
    @Override
    public String getHelp() {
        return "Generates My Custom language client library.";
    }
    
    @Override
    public CodegenType getTag() {
        return CodegenType.CLIENT;
    }
    
    // Override methods to customize behavior
    @Override
    public String toModelName(String name) {
        // Custom model name transformation
        return camelize(sanitizeName(name));
    }
}

Executing Generation

// Using DefaultGenerator with configuration
CodegenConfigurator configurator = new CodegenConfigurator()
    .setGeneratorName("java")
    .setInputSpec("openapi.yaml")
    .setOutputDir("./generated")
    .setApiPackage("com.example.api")
    .setModelPackage("com.example.model");

DefaultGenerator generator = new DefaultGenerator();
List<File> generatedFiles = generator.opts(configurator.toClientOptInput()).generate();

// Process generated files
for (File file : generatedFiles) {
    System.out.println("Generated: " + file.getAbsolutePath());
}

Custom Post-Processing

public class CustomPostProcessingGenerator extends DefaultCodegen {
    
    @Override
    public Map<String, ModelsMap> postProcessAllModels(Map<String, ModelsMap> objs) {
        // Apply custom transformations to all models
        Map<String, ModelsMap> result = super.postProcessAllModels(objs);
        
        for (ModelsMap models : result.values()) {
            for (ModelMap model : models.getModels()) {
                CodegenModel codegenModel = (CodegenModel) model.get("model");
                
                // Add custom properties or modify model
                codegenModel.vendorExtensions.put("x-custom-annotation", true);
            }
        }
        
        return result;
    }
    
    @Override
    public OperationsMap postProcessOperationsWithModels(OperationsMap objs, List<ModelMap> allModels) {
        OperationsMap result = super.postProcessOperationsWithModels(objs, allModels);
        
        // Customize operations
        OperationMap operations = result.getOperations();
        for (CodegenOperation operation : (List<CodegenOperation>) operations.get("operation")) {
            // Add custom operation properties
            operation.vendorExtensions.put("x-custom-header", "MyHeader");
        }
        
        return result;
    }
}

Supporting Classes

SupportingFile

Represents additional files to be generated alongside API and model files.

class SupportingFile extends TemplateDefinition {
    // Constructors
    public SupportingFile(String templateFile, String destinationFilename);
    public SupportingFile(String templateFile, String folder, String destinationFilename);
    
    // Configuration
    public SupportingFile templateFile(String templateFile);
    public SupportingFile folder(String folder);
    public SupportingFile destinationFilename(String destinationFilename);
    
    // Getters
    public String getTemplateFile();
    public String getFolder();
    public String getDestinationFilename();
}

VendorExtension

Configuration for vendor extensions (x-* properties).

class VendorExtension {
    public String name;              // Extension name (e.g., "x-my-extension")
    public String description;       // Human-readable description
    public String type;             // Data type (string, boolean, etc.)
    public Object defaultValue;     // Default value
    public List<String> enumValues; // Allowed values for enum types
}

Install with Tessl CLI

npx tessl i tessl/maven-org-openapitools--openapi-generator

docs