playbooks

home / skills / jeremylongshore / claude-code-plugins-plus-skills / generating-rest-apis

generating-rest-apis skill

/plugins/api-development/rest-api-generator/skills/generating-rest-apis

This skill generates complete REST API implementations from OpenAPI specs or schemas, producing boilerplate, endpoints, and tests to accelerate backend

npx playbooks add skill jeremylongshore/claude-code-plugins-plus-skills --skill generating-rest-apis

Review the files below or copy the command above to add this skill to your agents.

Files (4)
SKILL.md
2.4 KB
---
name: generating-rest-apis
description: |
  Generate complete REST API implementations from OpenAPI specifications or database schemas.
  Use when generating RESTful API implementations.
  Trigger with phrases like "generate REST API", "create RESTful API", or "build REST endpoints".
  
allowed-tools: Read, Write, Edit, Grep, Glob, Bash(api:rest-*)
version: 1.0.0
author: Jeremy Longshore <[email protected]>
license: MIT
---

# Generating Rest Apis

## Overview


This skill provides automated assistance for rest api generator tasks.
This skill provides automated assistance for the described functionality.

## Prerequisites

Before using this skill, ensure you have:
- API design specifications or requirements documented
- Development environment with necessary frameworks installed
- Database or backend services accessible for integration
- Authentication and authorization strategies defined
- Testing tools and environments configured

## Instructions

1. Use Read tool to examine existing API specifications from {baseDir}/api-specs/
2. Define resource models, endpoints, and HTTP methods
3. Document request/response schemas and data types
4. Identify authentication and authorization requirements
5. Plan error handling and validation strategies
1. Generate boilerplate code using Bash(api:rest-*) with framework scaffolding
2. Implement endpoint handlers with business logic
3. Add input validation and schema enforcement
4. Integrate authentication and authorization middleware
5. Configure database connections and ORM models
1. Write integration tests covering all endpoints


See `{baseDir}/references/implementation.md` for detailed implementation guide.

## Output

- `{baseDir}/src/routes/` - Endpoint route definitions
- `{baseDir}/src/controllers/` - Business logic handlers
- `{baseDir}/src/models/` - Data models and schemas
- `{baseDir}/src/middleware/` - Authentication, validation, logging
- `{baseDir}/src/config/` - Configuration and environment variables
- OpenAPI 3.0 specification with complete endpoint definitions

## Error Handling

See `{baseDir}/references/errors.md` for comprehensive error handling.

## Examples

See `{baseDir}/references/examples.md` for detailed examples.

## Resources

- Express.js and Fastify for Node.js APIs
- Flask and FastAPI for Python APIs
- Spring Boot for Java APIs
- Gin and Echo for Go APIs
- OpenAPI Specification 3.0+ for API documentation

Overview

This skill generates complete REST API implementations from OpenAPI specifications or database schemas. It scaffolds routes, controllers, models, middleware, and configuration, producing a ready-to-run codebase. The output includes an OpenAPI 3.0 document and integration tests to validate endpoints.

How this skill works

Provide an OpenAPI spec or a database schema and the skill analyzes resources, endpoints, request/response schemas, and authentication requirements. It creates framework scaffolding (Express/FastAPI/Flask/etc.), route definitions, controller stubs, ORM models, and middleware for validation and auth. The skill also configures environment files, database connections, and generates basic integration tests. Finally, it emits a complete OpenAPI 3.0 spec aligned with the generated code.

When to use it

  • You have an OpenAPI 3.0 specification and need a runnable API implementation.
  • You want to convert a database schema into CRUD endpoints quickly.
  • You need consistent scaffolding across projects and teams.
  • You want automated generation of validation, auth hooks, and test stubs.
  • You’re bootstrapping a prototype or accelerating backend development.

Best practices

  • Provide a complete and well-typed OpenAPI spec or a normalized database schema to improve accuracy.
  • Define authentication and authorization strategies before generation to ensure secure middleware placement.
  • Review and customize generated business logic; generators create stubs not final domain rules.
  • Use generated integration tests as a baseline and extend them with edge-case coverage.
  • Keep environment-specific secrets out of generated config and manage them via your secrets store.

Example use cases

  • Generate a Python FastAPI service from an OpenAPI file to quickly expose CRUD endpoints for a product catalog.
  • scaffold an Express.js API with JWT authentication from a database schema for a new SaaS module.
  • Create prototype endpoints from a legacy database schema to validate frontend integration.
  • Produce consistent API skeletons across microservices to speed onboarding and code reviews.
  • Generate endpoint definitions and OpenAPI docs for automated client SDK generation.

FAQ

What inputs does the skill accept?

It accepts OpenAPI 3.0 specifications or database schemas (SQL DDL or introspected schema) and basic config for framework choice and auth method.

Which frameworks are supported?

Common targets include Express and Fastify for Node.js, Flask and FastAPI for Python, Spring Boot for Java, and Gin/Echo for Go; output adapts to chosen target.

Is the generated code production-ready?

The generated code provides a solid, secure scaffold with validation and auth hooks, but you should implement domain-specific business logic, detailed error handling, and harden security for production.