Backend Framework Support

Express.js Framework Support

LogicStamp Context provides comprehensive support for Express.js applications, automatically detecting routes, API handlers, and extracting API signatures from your backend code.

Express.js Detection

LogicStamp automatically identifies Express.js code by:

Express imports: Detects imports from express and express/* packages
Route patterns: Recognizes app.get(), app.post(), router.get(), router.post(), etc.
HTTP methods: Detects GET, POST, PUT, DELETE, PATCH, and ALL methods
Route handlers: Identifies named functions and anonymous handlers

Detection requires both: (1) Express import (import express from 'express') and (2) Route method calls (app.get(), router.post(), etc.). This two-factor detection prevents false positives - files that import Express but don't define routes won't be detected as backend files.

Routes

Express routes are automatically detected and analyzed:

// Example: routes/users.ts
import express from 'express';
const router = express.Router();

function getUsers(req: express.Request, res: express.Response) {
  res.json({ users: [] });
}

router.get('/users', getUsers);
router.post('/users', (req, res) => {
  res.json({ created: true });
});

Extracted information:

Route paths: /users, /users/:id
HTTP methods: GET, POST, PUT, DELETE, PATCH, ALL
Handler function names: getUsers or anonymous for inline handlers
Route parameters: ['id'] from paths like /users/:id

API Signatures

For named handler functions, LogicStamp extracts API signatures:

import express, { Request, Response } from 'express';

function createUser(
  req: Request<{}, UserResponse, CreateUserRequest>,
  res: Response<UserResponse>
): void {
  const user = req.body;
  // ... create user logic
  res.status(201).json({ id: '123', ...user });
}

app.post('/users', createUser);

Extracted API signature:

Parameters: { req: Request<{}, UserResponse, CreateUserRequest>, res: Response<UserResponse> }
Return type: void
Request type: CreateUserRequest (for POST/PUT/PATCH)
Response type: UserResponse

Note: API signatures are only extracted for named handler functions. Anonymous handlers don't have API signatures extracted.

Component Kinds

LogicStamp categorizes Express files into different kinds:

node:api

Express route files with route definitions

ts:module

TypeScript modules/utilities (non-route files)

Usage

Generate context for an Express.js project:

# Analyze Express.js project
stamp context

# The tool will automatically:
# 1. Detect Express imports and route patterns
# 2. Extract route definitions (paths, methods, handlers)
# 3. Extract API signatures from named handlers
# 4. Identify route parameters
# 5. Generate structured contracts for each route file

Best Practices

1. Use Named Handler Functions

Named functions enable API signature extraction:

// ✅ Good: Named function with types
function getUserById(
  req: Request<{ id: string }>,
  res: Response<User>
): void {
  // ...
}
app.get('/users/:id', getUserById);

// ❌ Less ideal: Anonymous handler (no API signature extraction)
app.get('/users/:id', (req, res) => {
  // ...
});

2. Type Your Request/Response

TypeScript types improve extraction quality:

// ✅ Good: Typed request and response
interface CreateUserRequest {
  name: string;
  email: string;
}

interface UserResponse {
  id: string;
  name: string;
  email: string;
}

function createUser(
  req: Request<{}, UserResponse, CreateUserRequest>,
  res: Response<UserResponse>
): void {
  // ...
}

Limitations

Middleware Extraction

Express middleware is not currently extracted. LogicStamp focuses on extracting API routes and their signatures. The extractor only looks for HTTP method calls (get, post, put, delete, patch, all) and doesn't process app.use() calls for middleware.

Route Composition

Nested route composition may not be fully tracked. LogicStamp analyzes each file independently. When you mount a router with app.use('/api', router), the extractor sees this as a middleware call (not a route), so it's not extracted. The routes are extracted from the router file itself, but the full path (/api/users) isn't computed.

Dynamic Route Paths

Only string literal paths are extracted. LogicStamp uses static analysis and can only extract values that are known at compile time. Dynamic paths require runtime evaluation, which static analysis cannot perform.

Anonymous Handlers

Anonymous handlers don't have API signatures extracted. The API signature extractor requires a function name to locate and analyze the function definition. Anonymous handlers are inline and don't have separate definitions that can be analyzed.

Next Steps

Get started with LogicStamp Context or explore other backend framework integrations.

Get Started NestJS Support GitHub Repository