Generate Rest Api

Automatically generate comprehensive RESTful API implementations from schema definitions with proper routing, validation, error handling, authentication, pagination, and OpenAPI documentation following industry best practices.

When to Use This Command

Use /generate-rest-api when you need to:

• Build CRUD APIs quickly with consistent patterns
• Create microservices with RESTful interfaces
• Generate APIs from database schemas or models
• Implement standardized API patterns across projects
• Support multiple client applications (web, mobile, IoT)
• Build public APIs with comprehensive documentation

DON'T use this when:

• Building real-time applications (consider WebSocket/gRPC)
• Internal services need maximum performance (consider gRPC)
• Complex event-driven architectures (consider event streaming)
• GraphQL would better serve client needs

Design Decisions

This command implements OpenAPI-first design as the primary approach because:

• Contract-first development ensures consistency
• Auto-generates server stubs and client SDKs
• Provides interactive API documentation
• Enables API mocking during development
• Supports multiple framework implementations
• Industry-standard specification format

Alternative considered: Code-first with annotations

• Faster initial development
• Tighter coupling to implementation
• Less portable across frameworks
• Recommended for rapid prototyping

Alternative considered: GraphQL

• More flexible client queries
• Reduced over/under-fetching
• Higher complexity
• Recommended for complex client needs

Prerequisites

Before running this command:

1. Define your data models and relationships
2. Choose target framework (Express, FastAPI, NestJS, etc.)
3. Select database technology
4. Determine authentication requirements
5. Plan API versioning strategy

Implementation Process

Step 1: Define OpenAPI Specification

Create comprehensive API contracts with schemas, endpoints, and examples.

Step 2: Generate Server Stubs

Build framework-specific implementations from OpenAPI specs.

Step 3: Implement Business Logic

Add controllers, services, and data access layers.

Step 4: Add Middleware

Configure authentication, validation, rate limiting, and CORS.

Step 5: Generate Documentation

Create interactive docs, client SDKs, and Postman collections.

Output Format

The command generates:

• openapi.yaml - Complete API specification
• src/controllers/ - Request handlers with business logic
• src/routes/ - RESTful endpoint definitions
• src/models/ - Data models and schemas
• src/middleware/ - Auth, validation, rate limiting
• src/services/ - Business logic layer
• tests/ - Integration and unit tests
• docs/ - API documentation and examples

Code Examples

Example 1: E-commerce API with Express.js and TypeScript

# openapi.yaml
openapi: 3.0.0
info:
  title: E-commerce API
  version: 1.0.0
  description: RESTful API for e-commerce platform

servers:
  - url: https://api.example.com/v1
    description: Production server
  - url: http://localhost:3000/v1
    description: Development server

components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
…

// src/app.ts - Express application setup
import express, { Application } from 'express';
import helmet from 'helmet';
import cors from 'cors';
import compression from 'compression';
import morgan from 'morgan';
import swaggerUi from 'swagger-ui-express';
import { rateLimit } from 'express-rate-limit';
import { errorHandler } from './middleware/errorHandler';
import { notFoundHandler } from './middleware/notFoundHandler';
import { authMiddleware } from './middleware/auth';
import { validationMiddleware } from './middleware/validation';
import { productRouter } from './routes/products';
import { loadOpenAPISpec } from './utils/openapi';

export class App {
    public app: Application;
…

Example 2: FastAPI Implementation with Python

# main.py - FastAPI application
from fastapi import FastAPI, HTTPException, Query, Depends, status
from fastapi.middleware.cors import CORSMiddleware
from fastapi.middleware.trustedhost import TrustedHostMiddleware
from fastapi.middleware.gzip import GZipMiddleware
from fastapi.responses import JSONResponse
from slowapi import Limiter, _rate_limit_exceeded_handler
from slowapi.util import get_remote_address
from slowapi.errors import RateLimitExceeded
from typing import Optional, List
from datetime import datetime
from pydantic import BaseModel, Field, validator
import uvicorn

# Create rate limiter
limiter = Limiter(key_func=get_remote_address)

# Create FastAPI app
…

Example 3: Integration Tests

// tests/products.test.js
const request = require('supertest');
const { app } = require('../src/app');
const { generateToken } = require('../src/utils/auth');

describe('Products API', () => {
    let authToken;
    let productId;

    beforeAll(async () => {
        // Generate auth token for protected routes
        authToken = await generateToken({ userId: 'test-user', role: 'admin' });
    });

    describe('GET /v1/products', () => {
        it('should return paginated products', async () => {
            const res = await request(app)
                .get('/v1/products')
…