Express Api

Name: Express Api
Author: aidotnet

aidotnet/moyucode

28 installs
84 repo stars
Updated January 28, 2026
aidotnet/moyucode

express-api is a Claude Code skill that generates structured Express.js REST APIs in TypeScript with middleware, validation, auth and error handling.

About

express-api is a Claude Code skill that generates Express.js REST APIs in TypeScript. It scaffolds app setup, routers, controllers, middleware, request validation, authentication and error handling. A developer uses it to bootstrap a structured Node.js backend. It ships worked examples of the full request pipeline.

Generates Express.js REST APIs in TypeScript
Wires middleware, validation, auth and error handling
Provides router, controller and service scaffolding

Express Api by the numbers

28 all-time installs (skills.sh)
Ranked #3,395 of 4,347 Backend & APIs skills by installs in the Skillselion catalog
Data as of Jul 28, 2026 (Skillselion catalog sync)

At a glance

express-api capabilities & compatibility

Capabilities: express api · rest api scaffolding · api development
Use cases: api development
Pricing: Free

From the docs

What express-api says it does

Generate Express.js REST APIs with TypeScript and best practices.

SKILL.md

You are an Express.js expert that creates production-ready APIs.

SKILL.md

npx skills add https://github.com/aidotnet/moyucode --skill express-api

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

[![Listed on Skillselion](https://skillselion.com/badge/skills/aidotnet/moyucode/express-api.svg)](https://skillselion.com/skills/aidotnet/moyucode/express-api)

Installs	28
repo stars	★ 84
Last updated	January 28, 2026
Repository	aidotnet/moyucode ↗

What it does

Scaffold a structured Express.js REST API in TypeScript with middleware and auth.

Who is it for?

Developers bootstrapping a structured Node.js REST API on Express.

Skip if: Non-Express frameworks or GraphQL-first backends.

When should I use this skill?

You need to scaffold an Express REST API with routers, controllers and middleware.

What you get

A structured Express.js REST API with middleware, validation and auth is generated.

Express app scaffold
routers
controllers

By the numbers

5 REST routes in the user example (get all, get by id, create, update, delete)

Files

SKILL.mdMarkdownGitHub ↗

Express API Skill

Description

Generate Express.js REST APIs with TypeScript and best practices.

Trigger

/express command
User requests Express API
User needs Node.js backend

Prompt

You are an Express.js expert that creates production-ready APIs.

Express App Setup

// src/app.ts
import express, { Express, Request, Response, NextFunction } from 'express';
import cors from 'cors';
import helmet from 'helmet';
import morgan from 'morgan';
import { router } from './routes';
import { errorHandler } from './middleware/errorHandler';

const app: Express = express();

// Middleware
app.use(helmet());
app.use(cors({ origin: process.env.CORS_ORIGIN, credentials: true }));
app.use(morgan('combined'));
app.use(express.json({ limit: '10mb' }));
app.use(express.urlencoded({ extended: true }));

// Routes
app.use('/api/v1', router);

// Health check
app.get('/health', (req, res) => {
  res.json({ status: 'ok', timestamp: new Date().toISOString() });
});

// Error handling
app.use(errorHandler);

export { app };

Router with Controllers

// src/routes/users.ts
import { Router } from 'express';
import { UserController } from '../controllers/UserController';
import { validate } from '../middleware/validate';
import { authenticate } from '../middleware/auth';
import { CreateUserSchema, UpdateUserSchema } from '../schemas/user';

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

router.get('/', authenticate, controller.getAll);
router.get('/:id', authenticate, controller.getById);
router.post('/', validate(CreateUserSchema), controller.create);
router.put('/:id', authenticate, validate(UpdateUserSchema), controller.update);
router.delete('/:id', authenticate, controller.delete);

export { router as userRouter };

Controller

// src/controllers/UserController.ts
import { Request, Response, NextFunction } from 'express';
import { UserService } from '../services/UserService';
import { AppError } from '../utils/AppError';

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

  getAll = async (req: Request, res: Response, next: NextFunction) => {
    try {
      const { page = 1, limit = 10 } = req.query;
      const users = await this.userService.findAll({
        page: Number(page),
        limit: Number(limit),
      });
      res.json(users);
    } catch (error) {
      next(error);
    }
  };

  getById = async (req: Request, res: Response, next: NextFunction) => {
    try {
      const user = await this.userService.findById(req.params.id);
      if (!user) {
        throw new AppError('User not found', 404);
      }
      res.json(user);
    } catch (error) {
      next(error);
    }
  };

  create = async (req: Request, res: Response, next: NextFunction) => {
    try {
      const user = await this.userService.create(req.body);
      res.status(201).json(user);
    } catch (error) {
      next(error);
    }
  };
}

Error Handler Middleware

// src/middleware/errorHandler.ts
import { Request, Response, NextFunction } from 'express';
import { AppError } from '../utils/AppError';

export function errorHandler(
  err: Error,
  req: Request,
  res: Response,
  next: NextFunction
) {
  console.error(err);

  if (err instanceof AppError) {
    return res.status(err.statusCode).json({
      error: {
        code: err.code,
        message: err.message,
      },
    });
  }

  res.status(500).json({
    error: {
      code: 'INTERNAL_ERROR',
      message: 'An unexpected error occurred',
    },
  });
}

Validation Middleware

// src/middleware/validate.ts
import { Request, Response, NextFunction } from 'express';
import { ZodSchema } from 'zod';

export function validate(schema: ZodSchema) {
  return (req: Request, res: Response, next: NextFunction) => {
    const result = schema.safeParse(req.body);
    if (!result.success) {
      return res.status(400).json({
        error: {
          code: 'VALIDATION_ERROR',
          details: result.error.errors,
        },
      });
    }
    req.body = result.data;
    next();
  };
}