OpenAPI Generator Server Generation: Build API Server Stubs from Specs

# Generate Python Flask server
openapi-generator generate \
  -i openapi.yaml \
  -g python-flask \
  -o ./server-python \
  --additional-properties=packageName=dodatech_api

# Generated structure:
# ./server-python/
#   openapi_server/
#     controllers/     # Stub controllers to implement
#     models/          # Data models (auto-generated)
#     openapi/         # Original spec copy
#     encoder.py
#     util.py
#   requirements.txt
#   setup.py

# Generated controller stub (openapi_server/controllers/user_controller.py)
import connexion
from typing import Any
from openapi_server.models.user import User
from openapi_server.models.error import Error

def create_user(body: User) -> tuple[User, int]:
    """Create a new user.

    Implement this function with your business logic.
    """
    # TODO: Implement user creation
    # 1. Validate input
    # 2. Save to database
    # 3. Return created user
    return body, 201

def get_user(user_id: int) -> tuple[User | Error, int]:
    """Get user by ID."""
    # TODO: Implement
    # user = db.session.get(User, user_id)
    # if user:
    #     return user, 200
    return Error(message="User not found"), 404

def list_users(limit: int = 20, offset: int = 0) -> tuple[list[User], int]:
    """List users with pagination."""
    # TODO: Implement
    # users = db.session.query(User).limit(limit).offset(offset).all()
    # return users, 200
    return [], 200

# Generate Express server
openapi-generator generate \
  -i openapi.yaml \
  -g nodejs-express-server \
  -o ./server-node \
  --additional-properties=serverPort=8080

// Generated controller (controllers/UserController.js)
'use strict';

const utils = require('../utils/writer.js');
const User = require('../service/UserService');

module.exports.createUser = function createUser(req, res, next) {
    const body = req.swagger.params.body.value;
    User.createUser(body)
        .then((response) => {
            utils.writeJson(res, response, 201);
        })
        .catch((error) => {
            utils.writeJson(res, { message: error.message }, error.status || 500);
        });
};

module.exports.getUser = function getUser(req, res, next) {
    const userId = req.swagger.params.userId.value;
    User.getUser(userId)
        .then((response) => {
            if (response) {
                utils.writeJson(res, response);
            } else {
                utils.writeJson(res, { message: 'Not found' }, 404);
            }
        })
        .catch((error) => {
            utils.writeJson(res, { message: error.message }, 500);
        });
};

# Generate Spring Boot server
openapi-generator generate \
  -i openapi.yaml \
  -g spring \
  -o ./server-java \
  --additional-properties=\
useSpringBoot3=true,\
useJakartaEe=true,\
apiPackage=com.dodatech.api,\
modelPackage=com.dodatech.model

// Generated controller interface (com/dodatech/api/UsersApi.java)
package com.dodatech.api;

import com.dodatech.model.User;
import com.dodatech.model.Error;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/v1")
public interface UsersApi {

    @PostMapping("/users")
    ResponseEntity<User> createUser(@RequestBody User body);

    @GetMapping("/users/{userId}")
    ResponseEntity<User> getUser(@PathVariable Long userId);

    @GetMapping("/users")
    ResponseEntity<List<User>> listUsers(
        @RequestParam(defaultValue = "20") Integer limit,
        @RequestParam(defaultValue = "0") Integer offset
    );
}

// Implementation (com/dodatech/api/UsersApiController.java)
@RestController
public class UsersApiController implements UsersApi {

    @Autowired
    private UserRepository userRepository;

    @Override
    public ResponseEntity<User> createUser(User body) {
        User user = userRepository.save(body);
        return ResponseEntity.status(201).body(user);
    }

    @Override
    public ResponseEntity<User> getUser(Long userId) {
        return userRepository.findById(userId)
            .map(ResponseEntity::ok)
            .orElse(ResponseEntity.notFound().build());
    }

    @Override
    public ResponseEntity<List<User>> listUsers(Integer limit, Integer offset) {
        Pageable pageable = PageRequest.of(offset / limit, limit);
        Page<User> users = userRepository.findAll(pageable);
        return ResponseEntity.ok(users.getContent());
    }
}