mcpField
A
api-endpoint-scaffolder

api-endpoint-scaffolder

github.com/onewave-aiDevelopment393302 installsUpdated 1w ago
Repository

About api-endpoint-scaffolder

A skill for scaffolding API endpoints across frameworks such as Next.js and Express. It guides developers through HTTP methods, request and response types, input validation, status codes, and implementation practices.

Key features

  1. 01Framework and HTTP method selection
  2. 02Request and response type definition
  3. 03Next.js and Express templates
  4. 04Input validation guidance
  5. 05Status code and error handling guidance

Use cases

  1. 01Scaffolding a new API route
  2. 02Adding request validation
  3. 03Standardizing endpoint responses
  4. 04Documenting endpoints with OpenAPI or Swagger

Install

Copy the command and run it in a terminal.

$npx skills add https://github.com/onewave-ai/claude-skills --skill api-endpoint-scaffolder

After installing, type/api-endpoint-scaffolderin Claude Code to confirm it loaded.

Details

From the project README

API Endpoint Scaffolder

Instructions

When creating a new API endpoint:

  1. Identify the framework (Express, Next.js, FastAPI, etc.)
  2. Determine HTTP method (GET, POST, PUT, PATCH, DELETE)
  3. Define request/response types
  4. Implement with best practices

Templates

Next.js App Router (TypeScript)
// app/api/[resource]/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { z } from 'zod';

const RequestSchema = z.object({
  // Define your schema
});

export async function GET(request: NextRequest) {
  try {
    const { searchParams } = new URL(request.url);
    // Implementation
    return NextResponse.json({ data }, { status: 200 });
  } catch (error) {
    console.error('[API] Error:', error);
    return NextResponse.json(
      { error: 'Internal server error' },
      { status: 500 }
    );
  }
}

export async function POST(request: NextRequest) {
  try {
    const body = await request.json();
    const validated = RequestSchema.parse(body);
    // Implementation
    return NextResponse.json({ data }, { status: 201 });
  } catch (error) {
    if (error instanceof z.ZodError) {
      return NextResponse.json(
        { error: 'Validation failed', details: error.errors },
        { status: 400 }
      );
    }
    return NextResponse.json(
      { error: 'Internal server error' },
      { status: 500 }
    );
  }
}
Express (TypeScript)
import { Router, Request, Response, NextFunction } from 'express';
import { z } from 'zod';

const router = Router();

const CreateSchema = z.object({
  // Define schema
});

router.post('/', async (req: Request, res: Response, next: NextFunction) => {
  try {
    const data = CreateSchema.parse(req.body);
    // Implementation
    res.status(201).json({ success: true, data });
  } catch (error) {
    next(error);
  }
});

export default router;

Best Practices

  1. Always validate input using Zod, Yup, or similar
  2. Use proper HTTP status codes:
    • 200: Success
    • 201: Created
    • 400: Bad Request
    • 401: Unauthorized
    • 403: Forbidden
    • 404: Not Found
    • 500: Server Error
  3. Log errors but don't expose internals to clients
  4. Use consistent response format
  5. Add rate limiting for public endpoints
  6. Document with OpenAPI/Swagger when possible

Comments

Markdown supported