К основному содержанию
скилл CX Codex

api-endpoint-generator — скилл для Claude Code: API и установка

Скилл api-endpoint-generator для Claude Code генерирует CRUD REST API с валидацией запросов, типами TypeScript, единым форматом ответов и документацией. Создаёт API-маршруты и backend endpoints.

MIT 294 установок ★ 64 обновлён 2026-01-12

Установить в Claude Code · Через Skills CLI (Vercel) Все способы и платформы ↓
npx skills add patricio0312rev/skills --skill api-endpoint-generator -a claude-code
Открыть на GitHub

Что делает api-endpoint-generator

Скилл берёт описание ресурса и раскладывает работу по шагам: создаёт маршруты POST, GET, PUT или PATCH и DELETE, схемы проверки тела и query-параметров, типы ответов и обработку ошибок. В описании используются Zod или Joi, интерфейсы TypeScript, примеры запросов и ответов, а также спецификации OpenAPI или Swagger.

В примере показана структура для Express + TypeScript: отдельные файлы для типов, схем, маршрутов, контроллера и middleware валидации. Контроллер обращается к сервису, возвращает единый ApiResponse и обрабатывает ситуацию, когда ресурс не найден. Без Express + TypeScript структуру из примера придётся адаптировать под другой стек.

Какие задачи решает

  • собрать CRUD-маршруты для ресурса
  • проверить тело и query-параметры запроса
  • описать типы ответов в TypeScript
  • согласовать формат ошибок API
  • подготовить OpenAPI или Swagger-документацию

Примеры запросов агенту

  • Сгенерируй CRUD REST API для ресурса User на Express + TypeScript с файлами types/user.types.ts, schemas/user.schema.ts и routes/users.routes.ts.
  • Добавь для API валидацию через Zod, типизированные ответы, единый формат ошибок и обработчики POST, GET, PATCH и DELETE.
  • Подготовь OpenAPI-документацию и примеры запросов и ответов для этих API-маршрутов.

Как установить api-endpoint-generator

1Через Skills CLI (Vercel)

npx skills add patricio0312rev/skills --skill api-endpoint-generator -a claude-code

2Вручную: положить файлы

~/.claude/skills/api-contract-normalizer/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/api-contract-normalizer/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы об api-endpoint-generator

Как установить api-endpoint-generator в Claude Code?

Выполните npx skills add patricio0312rev/skills --skill api-contract-normalizer -a claude-code, затем откройте ~/.claude/skills/api-contract-normalizer/SKILL.md.

Что делает api-endpoint-generator?

Скилл генерирует CRUD REST API с маршрутами, валидацией через Zod или Joi, типами TypeScript, едиными ответами, обработкой ошибок и документацией OpenAPI или Swagger.

На чём построен пример api-endpoint-generator?

Пример использует Express + TypeScript. Валидация показана через Zod; в описании также упоминается Joi.

Исходный текст

SKILL.md · MIT
---
name: api-endpoint-generator
description: Generates CRUD REST API endpoints with request validation, TypeScript types, consistent response formats, error handling, and documentation. Includes route handlers, validation schemas (Zod/Joi), typed responses, and usage examples. Use when building "REST API", "CRUD endpoints", "API routes", or "backend endpoints".
---

# API Endpoint Generator

Generate production-ready CRUD API endpoints with validation and type safety.

## Core Workflow

1. **Define resource**: Entity name and schema
2. **Generate routes**: POST, GET, PUT/PATCH, DELETE endpoints
3. **Add validation**: Request body/query validation with Zod/Joi
4. **Type responses**: TypeScript interfaces for all responses
5. **Error handling**: Consistent error responses
6. **Documentation**: OpenAPI/Swagger specs
7. **Examples**: Request/response samples

## Express + TypeScript Pattern

```typescript
// types/user.types.ts
export interface User {
  id: string;
  email: string;
  name: string;
  role: "user" | "admin";
  createdAt: Date;
  updatedAt: Date;
}

export interface CreateUserDto {
  email: string;
  name: string;
  password: string;
}

export interface UpdateUserDto {
  name?: string;
  email?: string;
}

export interface ApiResponse<T> {
  success: boolean;
  data?: T;
  error?: ApiError;
  meta?: PaginationMeta;
}

export interface ApiError {
  code: string;
  message: string;
  details?: Record<string, string[]>;
}
```

## Validation Schemas (Zod)

```typescript
// schemas/user.schema.ts
import { z } from "zod";

export const createUserSchema = z.object({
  email: z.string().email("Invalid email address"),
  name: z.string().min(2, "Name must be at least 2 characters"),
  password: z
    .string()
    .min(8, "Password must be at least 8 characters")
    .regex(/[A-Z]/, "Password must contain uppercase letter")
    .regex(/[0-9]/, "Password must contain number"),
});

export const updateUserSchema = z
  .object({
    name: z.string().min(2).optional(),
    email: z.string().email().optional(),
  })
  .refine((data) => Object.keys(data).length > 0, {
    message: "At least one field must be provided",
  });

export const getUsersQuerySchema = z.object({
  page: z.coerce.number().int().positive().default(1),
  limit: z.coerce.number().int().min(1).max(100).default(10),
  sortBy: z.enum(["name", "email", "createdAt"]).optional(),
  sortOrder: z.enum(["asc", "desc"]).default("desc"),
  search: z.string().optional(),
});

export type CreateUserDto = z.infer<typeof createUserSchema>;
export type UpdateUserDto = z.infer<typeof updateUserSchema>;
export type GetUsersQuery = z.infer<typeof getUsersQuerySchema>;
```

## CRUD Route Handlers

```typescript
// routes/users.routes.ts
import { Router } from "express";
import { UserController } from "../controllers/user.controller";
import { validateRequest } from "../middleware/validate";
import { authenticate } from "../middleware/auth";
import {
  createUserSchema,
  updateUserSchema,
  getUsersQuerySchema,
} from "../schemas/user.schema";

const router = Router();
const controller = new UserController();

// Create
router.post(
  "/",
  authenticate,
  validateRequest({ body: createUserSchema }),
  controller.create
);

// Read (list)
router.get(
  "/",
  authenticate,
  validateRequest({ query: getUsersQuerySchema }),
  controller.list
);

// Read (single)
router.get("/:id", authenticate, controller.getById);

// Update
router.patch(
  "/:id",
  authenticate,
  validateRequest({ body: updateUserSchema }),
  controller.update
);

// Delete
router.delete("/:id", authenticate, controller.delete);

export default router;
```

## Controller Implementation

```typescript
// controllers/user.controller.ts
import { Request, Response, NextFunction } from "express";
import { UserService } from "../services/user.service";
import {
  CreateUserDto,
  UpdateUserDto,
  GetUsersQuery,
} from "../types/user.types";
import { ApiResponse } from "../types/api.types";

export class UserController {
  private service = new UserService();

  create = async (
    req: Request<{}, {}, CreateUserDto>,
    res: Response<ApiResponse<User>>,
    next: NextFunction
  ) => {
    try {
      const user = await this.service.create(req.body);
      res.status(201).json({
        success: true,
        data: user,
      });
    } catch (error) {
      next(error);
    }
  };

  list = async (
    req: Request<{}, {}, {}, GetUsersQuery>,
    res: Response<ApiResponse<User[]>>,
    next: NextFunction
  ) => {
    try {
      const { page, limit, sortBy, sortOrder, search } = req.query;
      const result = await this.service.findAll({
        page,
        limit,
        sortBy,
        sortOrder,
        search,
      });

      res.json({
        success: true,
        data: result.users,
        meta: {
          page: result.page,
          limit: result.limit,
          total: result.total,
          totalPages: result.totalPages,
        },
      });
    } catch (error) {
      next(error);
    }
  };

  getById = async (
    req: Request<{ id: string }>,
    res: Response<ApiResponse<User>>,
    next: NextFunction
  ) => {
    try {
      const user = await this.service.findById(req.params.id);
      if (!user) {
        return res.status(404).json({
          success: false,
          error: {
            code: "USER_NOT_FOUND",
            message: "User not found",
          },
        });
      }
      res.json({
        success: true,
        data: user,
      });
    } catch (error) {
      next(error);
    }
  };

  update = async (
    req: Request<{ id: string }, {}, UpdateUserDto>,
    res: Response<ApiResponse<User>>,
    next: NextFunction
  ) => {
    try {
      const user = await this.service.update(req.params.id, req.body);
      if (!user) {
        return res.status(404).json({
          success: false,
          error: {
            code: "USER_NOT_FOUND",
            message: "User not found",
          },
        });
      }
      res.json({
        success: true,
        data: user,
      });
    } catch (error) {
      next(error);
    }
  };

  delete = async (
    req: Request<{ id: string }>,
    res: Response<ApiResponse<void>>,
    next: NextFunction
  ) => {
    try {
      const deleted = await this.service.delete(req.params.id);
      if (!deleted) {
        return res.status(404).json({
          success: false,
          error: {
            code: "USER_NOT_FOUND",
            message: "User not found",
          },
        });
      }
      res.status(204).send();
    } catch (error) {
      next(error);
    }
  };
}
```

## Validation Middleware

```typescript
// middleware/validate.ts
import { Request, Response, NextFunction } from "express";
import { ZodSchema } from "zod";

interface ValidationSchemas {
  body?: ZodSchema;
  query?: ZodSchema;
  params?: ZodSchema;
}

export const validateRequest = (schemas: ValidationSchemas) => {
  return (req: Request, res: Response, next: NextFunction) => {
    try {
      if (schemas.body) {
        req.body = schemas.body.parse(req.body);
      }
      if (schemas.query) {
        req.query = schemas.query.parse(req.query);
      }
      if (schemas.params) {
        req.params = schemas.params.parse(req.params);
      }
      next();
    } catch (error) {
      if (error instanceof z.ZodError) {
        return res.status(400).json({
          success: false,
          error: {
            code: "VALIDATION_ERROR",
            message: "Invalid request data",
            details: error.flatten().fieldErrors,
          },
        });
      }
      next(error);
    }
  };
};
```

## NestJS Pattern

```typescript
// users/users.controller.ts
import {
  Controller,
  Get,
  Post,
  Put,
  Delete,
  Body,
  Param,
  Query,
} from "@nestjs/common";
import { ApiTags, ApiOperation, ApiResponse } from "@nestjs/swagger";
import { UsersService } from "./users.service";
import { CreateUserDto, UpdateUserDto, GetUsersQueryDto } from "./dto";

@ApiTags("users")
@Controller("users")
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Post()
  @ApiOperation({ summary: "Create user" })
  @ApiResponse({ status: 201, description: "User created" })
  @ApiResponse({ status: 400, description: "Validation error" })
  async create(@Body() dto: CreateUserDto) {
    return this.usersService.create(dto);
  }

  @Get()
  @ApiOperation({ summary: "List users" })
  async findAll(@Query() query: GetUsersQueryDto) {
    return this.usersService.findAll(query);
  }

  @Get(":id")
  @ApiOperation({ summary: "Get user by ID" })
  async findOne(@Param("id") id: string) {
    return this.usersService.findOne(id);
  }

  @Put(":id")
  @ApiOperation({ summary: "Update user" })
  async update(@Param("id") id: string, @Body() dto: UpdateUserDto) {
    return this.usersService.update(id, dto);
  }

  @Delete(":id")
  @ApiOperation({ summary: "Delete user" })
  async remove(@Param("id") id: string) {
    return this.usersService.remove(id);
  }
}
```

## FastAPI Pattern (Python)

```python
# routers/users.py
from fastapi import APIRouter, Depends, HTTPException, Query
from typing import List, Optional
from pydantic import BaseModel, EmailStr, Field

router = APIRouter(prefix="/users", tags=["users"])

class CreateUserDto(BaseModel):
    email: EmailStr
    name: str = Field(..., min_length=2)
    password: str = Field(..., min_length=8)

class UserResponse(BaseModel):
    id: str
    email: str
    name: str
    role: str
    created_at: datetime

class PaginatedResponse(BaseModel):
    data: List[UserResponse]
    total: int
    page: int
    limit: int

@router.post("/", status_code=201, response_model=UserResponse)
async def create_user(dto: CreateUserDto, service: UserService = Depends()):
    return await service.create(dto)

@router.get("/", response_model=PaginatedResponse)
async def list_users(
    page: int = Query(1, ge=1),
    limit: int = Query(10, ge=1, le=100),
    search: Optional[str] = None,
    service: UserService = Depends()
):
    return await service.find_all(page, limit, search)
```

## Response Format Standards

```typescript
// Success Response
{
  "success": true,
  "data": { ... },
  "meta": {
    "page": 1,
    "limit": 10,
    "total": 50,
    "totalPages": 5
  }
}

// Error Response
{
  "success": false,
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "Invalid request data",
    "details": {
      "email": ["Invalid email address"],
      "password": ["Password must contain uppercase letter"]
    }
  }
}
```

## Status Codes

- 200: Success (GET, PUT)
- 201: Created (POST)
- 204: No Content (DELETE)
- 400: Validation Error
- 401: Unauthorized
- 403: Forbidden
- 404: Not Found
- 409: Conflict
- 500: Server Error

## Best Practices

1. **Type everything**: Request, response, DTOs, errors
2. **Validate early**: Before hitting service layer
3. **Consistent responses**: Same structure everywhere
4. **HTTP semantics**: Use correct status codes
5. **Error details**: Include validation errors
6. **Pagination**: Always paginate lists
7. **Filtering/sorting**: Support common queries
8. **Documentation**: OpenAPI/Swagger specs

## Output Checklist

- [ ] Route definitions with HTTP methods
- [ ] Request validation schemas
- [ ] TypeScript types for all DTOs
- [ ] Controller handlers with error handling
- [ ] Consistent response format
- [ ] Pagination for list endpoints
- [ ] HTTP status codes correctly used
- [ ] Error response format
- [ ] OpenAPI/Swagger documentation
- [ ] Usage examples with curl/requests

© patricio0312rev · MIT · patricio0312rev/skills

Похожие скиллы

Все скиллы по теме «Бэкенд и API» →
api-endpoint-scaffolder OneWave-AI Скилл api-endpoint-scaffolder собирает REST-эндпоинты по шаблонам для Next.js App Router и Express: схема Zod, коды ответов, обработка ошибок. CX Codex +1 317установок express-typescript Mindrally Скилл express-typescript для Claude Code задаёт правила для агента, который пишет API на Express.js и TypeScript: структуру проекта, работу с middleware, валидацию и безопасность. CX Codex +1 1 500установок nodejs-development Mindrally Скилл nodejs-development для Claude Code задаёт шаблоны Node.js и TypeScript для серверного и клиентского кода. CX Codex +1 800установок typespec-api-operations официальный github Скилл typespec-api-operations добавляет GET, POST, PATCH и DELETE в TypeSpec API-плагин для Microsoft 365 Copilot. Нужен при описании CRUD-маршрутов, параметров и карточек ответов. CX Codex +1 8 800установок nodejs-backend bobmatnyc Скилл nodejs-backend для Claude Code помогает собирать серверную часть на TypeScript с Express или Fastify. Включает работу с REST API, маршрутами, middleware и подключением базы данных. CX Codex +1 307установок nestjs-drizzle-crud-generator giuseppe-trisciuoglio Скилл nestjs-drizzle-crud-generator для Claude Code собирает модуль NestJS с Drizzle ORM: контроллер, сервис, DTO на Zod и тесты Jest по описанию полей. Создаёт раздел API под таблицу. CX Codex +1 3 800установок

Из того же набора148

Весь набор →
dependency-vulnerability-triage Скилл dependency-vulnerability-triage для Claude Code, Codex, Cursor и других платформ преобразует результаты npm audit и Snyk в пошаговый план патчей с оценкой серьёзности, безопасными путями обновления и анализом ломающих изменений. CX Codex +1 296установок rfc-generator Скилл rfc-generator собирает RFC по техническому предложению: проблема, решение, альтернативы, риски и план внедрения по готовому шаблону, а не с чистого листа. CX Codex +1 294установок backup-restore-runbook-generator Скилл backup-restore-runbook-generator для Claude Code создаёт планы аварийного восстановления баз данных, скрипты бэкапа и проверки restore. Включает DR-планирование и подготовку процедур отката. CX Codex +1 294установок cors-configuration Скилл cors-configuration описывает настройку CORS: список источников, заголовки ответа, preflight и credentials, с готовыми примерами для Express и Next.js. CX Codex +1 294установок table-builder Скилл table-builder генерирует таблицы данных на React с пагинацией, фильтрами, сортировкой и поддержкой серверного или клиентского рендеринга. CX Codex +1 293установок event-driven-architect Скилл event-driven-architect для Claude Code помогает проектировать событийную архитектуру: определять события, описывать их схемы и связывать публикацию с обработчиками. Также рассматривает CQRS и event sourcing. CX Codex +1 292установок input-validation-sanitization-auditor Скилл input-validation-sanitization-auditor находит и устраняет уязвимости XSS, SQL-инъекций и инъекций команд с помощью схем валидации и безопасных шаблонов кода. CX Codex +1 292установок prompt-template-builder Скилл prompt-template-builder для Claude Code собирает промпт из переиспользуемых частей: системной роли, переменных, формата ответа и примеров. Повторяющиеся запросы получают ответы в одном формате. CX Codex +1 291установок

Спонсоры проекта

Компании, которые помогают держать аналитику открытой