@re-shell/cli
Version:
Full-stack development platform uniting microservices and microfrontends. Build complete applications with .NET (ASP.NET Core Web API, Minimal API), Java (Spring Boot, Quarkus, Micronaut, Vert.x), Rust (Actix-Web, Warp, Rocket, Axum), Python (FastAPI, Dja
1,788 lines (1,535 loc) • 67.9 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.hyperExpressTemplate = void 0;
exports.hyperExpressTemplate = {
id: 'hyper-express',
name: 'hyper-express',
displayName: 'Hyper-Express',
description: 'High-performance HTTP server framework built on uWebSockets.js with Express-compatible API',
language: 'typescript',
framework: 'hyper-express',
version: '6.14.0',
tags: ['nodejs', 'hyper-express', 'api', 'rest', 'performance', 'websocket', 'uws', 'typescript'],
port: 3000,
dependencies: {},
features: ['extreme-performance', 'express-compatible', 'websocket', 'sse', 'streaming', 'jwt', 'prisma', 'redis'],
files: {
// Package configuration
'package.json': `{
"name": "{{projectName}}",
"version": "1.0.0",
"description": "Hyper-Express high-performance API server with TypeScript",
"main": "dist/index.js",
"scripts": {
"dev": "tsx watch src/index.ts",
"build": "tsc",
"start": "node dist/index.js",
"start:prod": "cross-env NODE_ENV=production node dist/index.js",
"lint": "eslint src --ext .ts",
"test": "jest",
"test:watch": "jest --watch",
"test:coverage": "jest --coverage",
"test:e2e": "jest --config ./test/jest-e2e.json",
"typecheck": "tsc --noEmit",
"format": "prettier --write .",
"migrate": "prisma migrate dev",
"migrate:deploy": "prisma migrate deploy",
"generate": "prisma generate",
"studio": "prisma studio",
"docker:build": "docker build -t {{projectName}} .",
"docker:run": "docker run -p 3000:3000 {{projectName}}"
},
"dependencies": {
"hyper-express": "^6.14.0",
"@prisma/client": "^5.13.0",
"prisma": "^5.13.0",
"redis": "^4.6.13",
"ioredis": "^5.3.2",
"jsonwebtoken": "^9.0.2",
"bcryptjs": "^2.4.3",
"dotenv": "^16.4.5",
"zod": "^3.22.4",
"dayjs": "^1.11.10",
"uuid": "^9.0.1",
"nanoid": "^3.3.7",
"pino": "^9.0.0",
"pino-pretty": "^11.0.0",
"helmet": "^7.1.0",
"cors": "^2.8.5",
"express-rate-limit": "^7.2.0",
"rate-limiter-flexible": "^5.0.0",
"multer": "^1.4.5-lts.1",
"sharp": "^0.33.3",
"nodemailer": "^6.9.13",
"bull": "^4.12.2",
"bullmq": "^5.7.1",
"node-cron": "^3.0.3",
"axios": "^1.6.8",
"lodash": "^4.17.21",
"@types/lodash": "^4.17.0",
"compression": "^1.7.4",
"express-validator": "^7.0.1",
"xss": "^1.0.15",
"dompurify": "^3.0.9",
"jsdom": "^24.0.0"
},
"devDependencies": {
"@types/node": "^20.12.7",
"@types/jsonwebtoken": "^9.0.6",
"@types/bcryptjs": "^2.4.6",
"@types/nodemailer": "^6.4.14",
"@types/bull": "^4.10.0",
"@types/node-cron": "^3.0.11",
"@types/multer": "^1.4.11",
"@types/compression": "^1.7.5",
"@types/cors": "^2.8.17",
"@typescript-eslint/eslint-plugin": "^7.7.1",
"@typescript-eslint/parser": "^7.7.1",
"eslint": "^8.57.0",
"eslint-config-prettier": "^9.1.0",
"prettier": "^3.2.5",
"typescript": "^5.4.5",
"tsx": "^4.7.2",
"cross-env": "^7.0.3",
"jest": "^29.7.0",
"ts-jest": "^29.1.2",
"@types/jest": "^29.5.12",
"supertest": "^7.0.0",
"@types/supertest": "^6.0.2"
}
}`,
// TypeScript configuration
'tsconfig.json': `{
"compilerOptions": {
"target": "ES2022",
"module": "commonjs",
"lib": ["ES2022"],
"outDir": "./dist",
"rootDir": "./src",
"strict": true,
"esModuleInterop": true,
"skipLibCheck": true,
"forceConsistentCasingInFileNames": true,
"resolveJsonModule": true,
"declaration": true,
"declarationMap": true,
"sourceMap": true,
"removeComments": true,
"noEmitOnError": true,
"allowSyntheticDefaultImports": true,
"experimentalDecorators": true,
"emitDecoratorMetadata": true,
"strictPropertyInitialization": false,
"moduleResolution": "node",
"baseUrl": ".",
"paths": {
"@/*": ["src/*"],
"@config/*": ["src/config/*"],
"@middleware/*": ["src/middleware/*"],
"@routes/*": ["src/routes/*"],
"@services/*": ["src/services/*"],
"@utils/*": ["src/utils/*"],
"@types/*": ["src/types/*"],
"@validators/*": ["src/validators/*"],
"@controllers/*": ["src/controllers/*"]
}
},
"include": ["src/**/*"],
"exclude": ["node_modules", "dist", "coverage", "test"]
}`,
// Main application entry
'src/index.ts': `import HyperExpress from 'hyper-express';
import { config } from './config/config';
import { logger } from './utils/logger';
import { setupMiddleware } from './middleware';
import { setupRoutes } from './routes';
import { initializeServices } from './services';
import { prisma } from './services/database';
import { redis } from './services/redis';
import { gracefulShutdown } from './utils/shutdown';
const app = new HyperExpress.Server({
// Enable HTTP/2 support
http2: true,
// Trust proxy headers
trust_proxy: true,
// Maximum request body size (10MB)
max_body_size: 10 * 1024 * 1024,
// Fast buffers for better performance
fast_buffers: true,
// Maximum headers count
max_headers_count: 100
});
async function bootstrap() {
try {
// Initialize services
await initializeServices();
// Setup middleware
setupMiddleware(app);
// Setup routes
setupRoutes(app);
// Error handler
app.set_error_handler((request, response, error) => {
logger.error({ error, path: request.path }, 'Unhandled error');
if (!response.headersSent) {
response.status(500).json({
success: false,
message: config.env === 'development' ? error.message : 'Internal server error',
...(config.env === 'development' && { stack: error.stack })
});
}
});
// 404 handler
app.any('*', (request, response) => {
response.status(404).json({
success: false,
message: 'Route not found',
path: request.path
});
});
// Start server
await app.listen(config.port, config.host);
logger.info({
port: config.port,
host: config.host,
environment: config.env,
http2: true
}, '🚀 Hyper-Express server started');
// Setup graceful shutdown
gracefulShutdown(app, prisma, redis);
} catch (error) {
logger.fatal({ error }, 'Failed to start server');
process.exit(1);
}
}
bootstrap();`,
// Configuration
'src/config/config.ts': `import { config as dotenvConfig } from 'dotenv';
import { z } from 'zod';
dotenvConfig();
const envSchema = z.object({
NODE_ENV: z.enum(['development', 'test', 'production']).default('development'),
PORT: z.string().default('3000').transform(Number),
HOST: z.string().default('0.0.0.0'),
// Database
DATABASE_URL: z.string(),
// Redis
REDIS_HOST: z.string().default('localhost'),
REDIS_PORT: z.string().default('6379').transform(Number),
REDIS_PASSWORD: z.string().optional(),
// JWT
JWT_SECRET: z.string(),
JWT_EXPIRES_IN: z.string().default('1h'),
JWT_REFRESH_SECRET: z.string(),
JWT_REFRESH_EXPIRES_IN: z.string().default('7d'),
// CORS
CORS_ORIGINS: z.string().default('http://localhost:3000'),
// Email
SMTP_HOST: z.string().optional(),
SMTP_PORT: z.string().default('587').transform(Number),
SMTP_USER: z.string().optional(),
SMTP_PASS: z.string().optional(),
EMAIL_FROM: z.string().default('noreply@example.com'),
// Logging
LOG_LEVEL: z.enum(['trace', 'debug', 'info', 'warn', 'error', 'fatal']).default('info'),
// Rate limiting
RATE_LIMIT_MAX: z.string().default('100').transform(Number),
RATE_LIMIT_WINDOW_MS: z.string().default('900000').transform(Number), // 15 minutes
// WebSocket
WS_MAX_PAYLOAD: z.string().default('1048576').transform(Number), // 1MB
WS_MAX_CONNECTIONS: z.string().default('10000').transform(Number),
// File upload
MAX_FILE_SIZE: z.string().default('10485760').transform(Number), // 10MB
UPLOAD_DIR: z.string().default('uploads')
});
const parsed = envSchema.safeParse(process.env);
if (!parsed.success) {
console.error('❌ Invalid environment variables:', parsed.error.format());
process.exit(1);
}
const env = parsed.data;
export const config = {
env: env.NODE_ENV,
port: env.PORT,
host: env.HOST,
logLevel: env.LOG_LEVEL,
database: {
url: env.DATABASE_URL
},
redis: {
host: env.REDIS_HOST,
port: env.REDIS_PORT,
password: env.REDIS_PASSWORD
},
jwt: {
secret: env.JWT_SECRET,
expiresIn: env.JWT_EXPIRES_IN,
refreshSecret: env.JWT_REFRESH_SECRET,
refreshExpiresIn: env.JWT_REFRESH_EXPIRES_IN
},
cors: {
origins: env.CORS_ORIGINS.split(',').map(origin => origin.trim())
},
email: {
host: env.SMTP_HOST,
port: env.SMTP_PORT,
user: env.SMTP_USER,
pass: env.SMTP_PASS,
from: env.EMAIL_FROM
},
rateLimit: {
max: env.RATE_LIMIT_MAX,
windowMs: env.RATE_LIMIT_WINDOW_MS
},
ws: {
maxPayload: env.WS_MAX_PAYLOAD,
maxConnections: env.WS_MAX_CONNECTIONS
},
upload: {
maxFileSize: env.MAX_FILE_SIZE,
dir: env.UPLOAD_DIR
}
} as const;`,
// Logger utility
'src/utils/logger.ts': `import pino from 'pino';
import { config } from '../config/config';
const transport = config.env === 'development'
? {
target: 'pino-pretty',
options: {
translateTime: 'HH:MM:ss Z',
ignore: 'pid,hostname',
colorize: true
}
}
: undefined;
export const logger = pino({
level: config.logLevel,
transport
});`,
// Middleware setup
'src/middleware/index.ts': `import HyperExpress from 'hyper-express';
import { corsMiddleware } from './cors';
import { compressionMiddleware } from './compression';
import { securityMiddleware } from './security';
import { loggingMiddleware } from './logging';
import { rateLimitMiddleware } from './rate-limit';
import { bodyParserMiddleware } from './body-parser';
export function setupMiddleware(app: HyperExpress.Server) {
// CORS
app.use(corsMiddleware);
// Security headers
app.use(securityMiddleware);
// Request logging
app.use(loggingMiddleware);
// Body parsing
app.use(bodyParserMiddleware);
// Compression
app.use(compressionMiddleware);
// Rate limiting
app.use('/api', rateLimitMiddleware);
}`,
// CORS middleware
'src/middleware/cors.ts': `import HyperExpress from 'hyper-express';
import { config } from '../config/config';
export const corsMiddleware: HyperExpress.MiddlewareHandler = (request, response, next) => {
const origin = request.headers['origin'];
if (origin && config.cors.origins.includes(origin)) {
response.header('Access-Control-Allow-Origin', origin);
} else if (config.cors.origins.includes('*')) {
response.header('Access-Control-Allow-Origin', '*');
}
response.header('Access-Control-Allow-Credentials', 'true');
response.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, PATCH, OPTIONS');
response.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization');
response.header('Access-Control-Max-Age', '86400');
if (request.method === 'OPTIONS') {
return response.status(204).end();
}
next();
};`,
// Security middleware
'src/middleware/security.ts': `import HyperExpress from 'hyper-express';
export const securityMiddleware: HyperExpress.MiddlewareHandler = (request, response, next) => {
// Helmet-like security headers
response.header('X-Content-Type-Options', 'nosniff');
response.header('X-Frame-Options', 'DENY');
response.header('X-XSS-Protection', '1; mode=block');
response.header('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
response.header('X-Powered-By', 'Hyper-Express');
response.header('Content-Security-Policy', "default-src 'self'");
response.header('X-DNS-Prefetch-Control', 'off');
response.header('X-Download-Options', 'noopen');
response.header('X-Permitted-Cross-Domain-Policies', 'none');
response.header('Referrer-Policy', 'no-referrer');
next();
};`,
// Compression middleware
'src/middleware/compression.ts': `import HyperExpress from 'hyper-express';
export const compressionMiddleware: HyperExpress.MiddlewareHandler = (request, response, next) => {
const acceptEncoding = request.headers['accept-encoding'] || '';
// Enable automatic compression for responses
if (acceptEncoding.includes('gzip')) {
response.header('Content-Encoding', 'gzip');
} else if (acceptEncoding.includes('br')) {
response.header('Content-Encoding', 'br');
} else if (acceptEncoding.includes('deflate')) {
response.header('Content-Encoding', 'deflate');
}
next();
};`,
// Body parser middleware
'src/middleware/body-parser.ts': `import HyperExpress from 'hyper-express';
import { config } from '../config/config';
export const bodyParserMiddleware: HyperExpress.MiddlewareHandler = async (request, response, next) => {
const contentType = request.headers['content-type'] || '';
try {
if (contentType.includes('application/json')) {
// JSON body parsing is automatic in Hyper-Express
// but we can add validation here if needed
} else if (contentType.includes('application/x-www-form-urlencoded')) {
// URL encoded form parsing
const body = await request.urlencoded();
request.body = body;
} else if (contentType.includes('multipart/form-data')) {
// Multipart parsing handled in upload routes
}
next();
} catch (error) {
response.status(400).json({
success: false,
message: 'Invalid request body'
});
}
};`,
// Logging middleware
'src/middleware/logging.ts': `import HyperExpress from 'hyper-express';
import { logger } from '../utils/logger';
import { nanoid } from 'nanoid';
export const loggingMiddleware: HyperExpress.MiddlewareHandler = (request, response, next) => {
const start = Date.now();
const requestId = nanoid();
// Add request ID to request object
(request as any).id = requestId;
// Log request
logger.info({
requestId,
method: request.method,
path: request.path,
query: request.query,
ip: request.ip,
userAgent: request.headers['user-agent']
}, 'Incoming request');
// Override response.send to log response
const originalSend = response.send.bind(response);
response.send = function(...args: any[]) {
const duration = Date.now() - start;
logger.info({
requestId,
method: request.method,
path: request.path,
statusCode: response.status_code,
duration
}, 'Request completed');
return originalSend(...args);
};
next();
};`,
// Rate limiting middleware
'src/middleware/rate-limit.ts': `import HyperExpress from 'hyper-express';
import { RateLimiterRedis } from 'rate-limiter-flexible';
import { redis } from '../services/redis';
import { config } from '../config/config';
import { logger } from '../utils/logger';
const rateLimiter = new RateLimiterRedis({
storeClient: redis,
keyPrefix: 'rate-limit',
points: config.rateLimit.max,
duration: config.rateLimit.windowMs / 1000, // Convert to seconds
blockDuration: 60 // Block for 1 minute
});
export const rateLimitMiddleware: HyperExpress.MiddlewareHandler = async (request, response, next) => {
try {
const key = request.ip || 'unknown';
await rateLimiter.consume(key);
next();
} catch (error) {
if (error instanceof Error && 'remainingPoints' in error) {
const rateLimiterRes = error as any;
response.header('Retry-After', String(Math.round(rateLimiterRes.msBeforeNext / 1000) || 60));
response.header('X-RateLimit-Limit', String(config.rateLimit.max));
response.header('X-RateLimit-Remaining', String(rateLimiterRes.remainingPoints || 0));
response.header('X-RateLimit-Reset', new Date(Date.now() + rateLimiterRes.msBeforeNext).toISOString());
return response.status(429).json({
success: false,
message: 'Too many requests',
retryAfter: Math.round(rateLimiterRes.msBeforeNext / 1000)
});
}
logger.error({ error }, 'Rate limiter error');
next();
}
};`,
// JWT authentication middleware
'src/middleware/auth.ts': `import HyperExpress from 'hyper-express';
import jwt from 'jsonwebtoken';
import { config } from '../config/config';
import { prisma } from '../services/database';
export interface JWTPayload {
id: string;
email: string;
role: string;
}
declare module 'hyper-express' {
interface Request {
user?: JWTPayload;
}
}
export const authenticate: HyperExpress.MiddlewareHandler = async (request, response, next) => {
try {
const authHeader = request.headers.authorization;
if (!authHeader || !authHeader.startsWith('Bearer ')) {
return response.status(401).json({
success: false,
message: 'No token provided'
});
}
const token = authHeader.substring(7);
const decoded = jwt.verify(token, config.jwt.secret) as JWTPayload;
// Verify user exists and is active
const user = await prisma.user.findUnique({
where: { id: decoded.id },
select: { id: true, isActive: true }
});
if (!user || !user.isActive) {
return response.status(401).json({
success: false,
message: 'Invalid token'
});
}
request.user = decoded;
next();
} catch (error) {
return response.status(401).json({
success: false,
message: 'Invalid token'
});
}
};
export const authorize = (...roles: string[]): HyperExpress.MiddlewareHandler => {
return (request, response, next) => {
if (!request.user) {
return response.status(401).json({
success: false,
message: 'Not authenticated'
});
}
if (!roles.includes(request.user.role)) {
return response.status(403).json({
success: false,
message: 'Insufficient permissions'
});
}
next();
};
};`,
// Routes setup
'src/routes/index.ts': `import HyperExpress from 'hyper-express';
import { healthRoutes } from './health';
import { authRoutes } from './auth';
import { userRoutes } from './users';
import { todoRoutes } from './todos';
import { uploadRoutes } from './upload';
import { wsRoutes } from './websocket';
import { sseRoutes } from './sse';
export function setupRoutes(app: HyperExpress.Server) {
// Health check routes
healthRoutes(app);
// API routes
const apiRouter = new HyperExpress.Router();
// Authentication routes
authRoutes(apiRouter);
// User routes
userRoutes(apiRouter);
// Todo routes
todoRoutes(apiRouter);
// Upload routes
uploadRoutes(apiRouter);
// Server-Sent Events routes
sseRoutes(apiRouter);
// Mount API router
app.use('/api/v1', apiRouter);
// WebSocket routes
wsRoutes(app);
}`,
// Health routes
'src/routes/health.ts': `import HyperExpress from 'hyper-express';
import { prisma } from '../services/database';
import { redis } from '../services/redis';
export function healthRoutes(app: HyperExpress.Server) {
app.get('/health', async (request, response) => {
response.json({
status: 'healthy',
timestamp: new Date().toISOString(),
uptime: process.uptime(),
environment: process.env.NODE_ENV,
version: process.env.npm_package_version || '1.0.0'
});
});
app.get('/health/ready', async (request, response) => {
const services = {
database: 'healthy',
redis: 'healthy'
};
try {
await prisma.$queryRaw\`SELECT 1\`;
} catch (error) {
services.database = 'unhealthy';
}
try {
await redis.ping();
} catch (error) {
services.redis = 'unhealthy';
}
const isHealthy = Object.values(services).every(status => status === 'healthy');
response.status(isHealthy ? 200 : 503).json({
status: isHealthy ? 'ready' : 'not ready',
services
});
});
}`,
// Authentication routes
'src/routes/auth.ts': `import HyperExpress from 'hyper-express';
import { authController } from '../controllers/auth.controller';
import { validateRequest } from '../middleware/validation';
import { RegisterSchema, LoginSchema, RefreshTokenSchema, ForgotPasswordSchema, ResetPasswordSchema } from '../validators/auth.validator';
import { authenticate } from '../middleware/auth';
export function authRoutes(router: HyperExpress.Router) {
// Register
router.post('/auth/register', validateRequest(RegisterSchema), authController.register);
// Login
router.post('/auth/login', validateRequest(LoginSchema), authController.login);
// Refresh token
router.post('/auth/refresh', validateRequest(RefreshTokenSchema), authController.refreshToken);
// Logout
router.post('/auth/logout', authenticate, authController.logout);
// Forgot password
router.post('/auth/forgot-password', validateRequest(ForgotPasswordSchema), authController.forgotPassword);
// Reset password
router.post('/auth/reset-password/:token', validateRequest(ResetPasswordSchema), authController.resetPassword);
// Verify email
router.get('/auth/verify-email/:token', authController.verifyEmail);
// Get current user
router.get('/auth/me', authenticate, authController.getCurrentUser);
}`,
// WebSocket routes
'src/routes/websocket.ts': `import HyperExpress from 'hyper-express';
import { logger } from '../utils/logger';
import { config } from '../config/config';
import jwt from 'jsonwebtoken';
import { JWTPayload } from '../middleware/auth';
interface WSClient {
id: string;
user?: JWTPayload;
channels: Set<string>;
}
const clients = new Map<HyperExpress.Websocket, WSClient>();
export function wsRoutes(app: HyperExpress.Server) {
// WebSocket endpoint
app.ws('/ws', {
compression: true,
maxPayloadLength: config.ws.maxPayload,
idleTimeout: 120,
maxBackpressure: 1024 * 1024 // 1MB
}, (ws) => {
const clientId = generateClientId();
const client: WSClient = {
id: clientId,
channels: new Set()
};
clients.set(ws, client);
logger.info({ clientId, total: clients.size }, 'WebSocket client connected');
// Send welcome message
ws.send(JSON.stringify({
type: 'welcome',
data: {
clientId,
timestamp: new Date().toISOString()
}
}));
// Handle authentication
ws.on('message', async (message) => {
try {
const data = JSON.parse(message.toString());
switch (data.type) {
case 'auth':
await handleAuth(ws, client, data.token);
break;
case 'subscribe':
handleSubscribe(ws, client, data.channel);
break;
case 'unsubscribe':
handleUnsubscribe(ws, client, data.channel);
break;
case 'publish':
await handlePublish(ws, client, data.channel, data.message);
break;
case 'ping':
ws.send(JSON.stringify({ type: 'pong' }));
break;
default:
ws.send(JSON.stringify({
type: 'error',
message: 'Unknown message type'
}));
}
} catch (error) {
logger.error({ error, clientId }, 'WebSocket message error');
ws.send(JSON.stringify({
type: 'error',
message: 'Invalid message format'
}));
}
});
// Handle disconnect
ws.on('close', () => {
clients.delete(ws);
logger.info({ clientId, total: clients.size }, 'WebSocket client disconnected');
});
});
// HTTP endpoint for publishing messages
app.post('/api/v1/ws/publish', async (request, response) => {
const { channel, message, requireAuth = false } = await request.json();
if (!channel || !message) {
return response.status(400).json({
success: false,
message: 'Channel and message are required'
});
}
let published = 0;
clients.forEach((client, ws) => {
if (client.channels.has(channel)) {
if (!requireAuth || client.user) {
ws.send(JSON.stringify({
type: 'message',
channel,
data: message,
timestamp: new Date().toISOString()
}));
published++;
}
}
});
response.json({
success: true,
published
});
});
}
async function handleAuth(ws: HyperExpress.Websocket, client: WSClient, token: string) {
try {
const decoded = jwt.verify(token, config.jwt.secret) as JWTPayload;
client.user = decoded;
ws.send(JSON.stringify({
type: 'auth_success',
user: {
id: decoded.id,
email: decoded.email,
role: decoded.role
}
}));
} catch (error) {
ws.send(JSON.stringify({
type: 'auth_error',
message: 'Invalid token'
}));
}
}
function handleSubscribe(ws: HyperExpress.Websocket, client: WSClient, channel: string) {
if (!channel) {
ws.send(JSON.stringify({
type: 'error',
message: 'Channel is required'
}));
return;
}
client.channels.add(channel);
ws.send(JSON.stringify({
type: 'subscribed',
channel
}));
logger.debug({ clientId: client.id, channel }, 'Client subscribed to channel');
}
function handleUnsubscribe(ws: HyperExpress.Websocket, client: WSClient, channel: string) {
if (!channel) {
ws.send(JSON.stringify({
type: 'error',
message: 'Channel is required'
}));
return;
}
client.channels.delete(channel);
ws.send(JSON.stringify({
type: 'unsubscribed',
channel
}));
logger.debug({ clientId: client.id, channel }, 'Client unsubscribed from channel');
}
async function handlePublish(ws: HyperExpress.Websocket, client: WSClient, channel: string, message: any) {
if (!client.user) {
ws.send(JSON.stringify({
type: 'error',
message: 'Authentication required to publish'
}));
return;
}
if (!channel || !message) {
ws.send(JSON.stringify({
type: 'error',
message: 'Channel and message are required'
}));
return;
}
// Broadcast to all subscribers
let published = 0;
clients.forEach((otherClient, otherWs) => {
if (otherClient.channels.has(channel) && otherWs !== ws) {
otherWs.send(JSON.stringify({
type: 'message',
channel,
data: message,
from: client.user?.id,
timestamp: new Date().toISOString()
}));
published++;
}
});
ws.send(JSON.stringify({
type: 'published',
channel,
published
}));
}
function generateClientId(): string {
return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
}`,
// Server-Sent Events routes
'src/routes/sse.ts': `import HyperExpress from 'hyper-express';
import { authenticate } from '../middleware/auth';
import { logger } from '../utils/logger';
interface SSEClient {
id: string;
response: HyperExpress.Response;
userId?: string;
}
const sseClients = new Map<string, SSEClient>();
export function sseRoutes(router: HyperExpress.Router) {
// SSE endpoint
router.get('/events', authenticate, (request, response) => {
const clientId = generateClientId();
const userId = request.user?.id;
// Set SSE headers
response.header('Content-Type', 'text/event-stream');
response.header('Cache-Control', 'no-cache');
response.header('Connection', 'keep-alive');
response.header('X-Accel-Buffering', 'no');
// Send initial connection event
response.write(\`event: connected\\ndata: {"clientId": "\${clientId}", "timestamp": "\${new Date().toISOString()}"}\\n\\n\`);
// Store client
const client: SSEClient = {
id: clientId,
response,
userId
};
sseClients.set(clientId, client);
logger.info({ clientId, userId, total: sseClients.size }, 'SSE client connected');
// Send heartbeat every 30 seconds
const heartbeatInterval = setInterval(() => {
response.write(':heartbeat\\n\\n');
}, 30000);
// Handle client disconnect
request.on('close', () => {
clearInterval(heartbeatInterval);
sseClients.delete(clientId);
logger.info({ clientId, total: sseClients.size }, 'SSE client disconnected');
});
});
// Broadcast endpoint
router.post('/events/broadcast', authenticate, async (request, response) => {
const { event, data, userIds } = await request.json();
if (!event || !data) {
return response.status(400).json({
success: false,
message: 'Event and data are required'
});
}
let sent = 0;
const message = \`event: \${event}\\ndata: \${JSON.stringify(data)}\\n\\n\`;
sseClients.forEach((client) => {
try {
// If userIds specified, only send to those users
if (!userIds || (client.userId && userIds.includes(client.userId))) {
client.response.write(message);
sent++;
}
} catch (error) {
// Client disconnected, remove from map
sseClients.delete(client.id);
}
});
response.json({
success: true,
sent
});
});
}
// Send event to specific user
export function sendSSEToUser(userId: string, event: string, data: any) {
const message = \`event: \${event}\\ndata: \${JSON.stringify(data)}\\n\\n\`;
let sent = 0;
sseClients.forEach((client) => {
if (client.userId === userId) {
try {
client.response.write(message);
sent++;
} catch (error) {
sseClients.delete(client.id);
}
}
});
return sent;
}
// Broadcast to all connected clients
export function broadcastSSE(event: string, data: any) {
const message = \`event: \${event}\\ndata: \${JSON.stringify(data)}\\n\\n\`;
let sent = 0;
sseClients.forEach((client) => {
try {
client.response.write(message);
sent++;
} catch (error) {
sseClients.delete(client.id);
}
});
return sent;
}
function generateClientId(): string {
return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
}`,
// File upload routes
'src/routes/upload.ts': `import HyperExpress from 'hyper-express';
import { authenticate } from '../middleware/auth';
import { uploadService } from '../services/upload.service';
import { logger } from '../utils/logger';
import { config } from '../config/config';
import path from 'path';
import fs from 'fs/promises';
export function uploadRoutes(router: HyperExpress.Router) {
// Single file upload
router.post('/upload/single', authenticate, async (request, response) => {
try {
const files = await request.files();
if (!files || files.length === 0) {
return response.status(400).json({
success: false,
message: 'No file uploaded'
});
}
const file = files[0];
// Validate file size
if (file.size > config.upload.maxFileSize) {
return response.status(400).json({
success: false,
message: 'File too large'
});
}
const result = await uploadService.uploadFile(file, request.user!.id);
response.json({
success: true,
file: result
});
} catch (error) {
logger.error({ error }, 'File upload error');
response.status(500).json({
success: false,
message: 'Upload failed'
});
}
});
// Multiple file upload
router.post('/upload/multiple', authenticate, async (request, response) => {
try {
const files = await request.files();
if (!files || files.length === 0) {
return response.status(400).json({
success: false,
message: 'No files uploaded'
});
}
const results = await Promise.all(
files.map(file => uploadService.uploadFile(file, request.user!.id))
);
response.json({
success: true,
files: results
});
} catch (error) {
logger.error({ error }, 'Multiple file upload error');
response.status(500).json({
success: false,
message: 'Upload failed'
});
}
});
// Stream upload for large files
router.post('/upload/stream', authenticate, async (request, response) => {
try {
const filename = request.headers['x-filename'] || 'unnamed';
const fileSize = parseInt(request.headers['content-length'] || '0');
if (fileSize > config.upload.maxFileSize * 10) { // Allow 10x for streaming
return response.status(400).json({
success: false,
message: 'File too large'
});
}
const uploadPath = path.join(config.upload.dir, \`\${Date.now()}-\${filename}\`);
await fs.mkdir(path.dirname(uploadPath), { recursive: true });
const writeStream = fs.createWriteStream(uploadPath);
let bytesReceived = 0;
request.on('data', (chunk) => {
bytesReceived += chunk.length;
writeStream.write(chunk);
// Send progress
if (bytesReceived % (1024 * 1024) === 0) { // Every MB
logger.debug({ filename, progress: bytesReceived / fileSize }, 'Upload progress');
}
});
request.on('end', async () => {
writeStream.end();
const result = await uploadService.processUploadedFile(uploadPath, request.user!.id);
response.json({
success: true,
file: result
});
});
request.on('error', (error) => {
logger.error({ error }, 'Stream upload error');
writeStream.destroy();
fs.unlink(uploadPath).catch(() => {});
response.status(500).json({
success: false,
message: 'Upload failed'
});
});
} catch (error) {
logger.error({ error }, 'Stream upload error');
response.status(500).json({
success: false,
message: 'Upload failed'
});
}
});
// Get uploaded file
router.get('/files/:id', authenticate, async (request, response) => {
try {
const file = await uploadService.getFile(request.params.id, request.user!.id);
if (!file) {
return response.status(404).json({
success: false,
message: 'File not found'
});
}
// Set appropriate headers
response.header('Content-Type', file.mimeType);
response.header('Content-Disposition', \`inline; filename="\${file.originalName}"\`);
// Stream file
const stream = await uploadService.getFileStream(file.path);
stream.pipe(response);
} catch (error) {
logger.error({ error }, 'File retrieval error');
response.status(500).json({
success: false,
message: 'Failed to retrieve file'
});
}
});
// Delete file
router.delete('/files/:id', authenticate, async (request, response) => {
try {
const success = await uploadService.deleteFile(request.params.id, request.user!.id);
if (!success) {
return response.status(404).json({
success: false,
message: 'File not found'
});
}
response.json({
success: true,
message: 'File deleted'
});
} catch (error) {
logger.error({ error }, 'File deletion error');
response.status(500).json({
success: false,
message: 'Failed to delete file'
});
}
});
}`,
// Validation middleware
'src/middleware/validation.ts': `import HyperExpress from 'hyper-express';
import { z } from 'zod';
import { logger } from '../utils/logger';
export function validateRequest<T extends z.ZodType>(schema: T): HyperExpress.MiddlewareHandler {
return async (request, response, next) => {
try {
const data = {
body: await request.json().catch(() => ({})),
query: request.query || {},
params: request.params || {}
};
const validated = await schema.parseAsync(data);
// Attach validated data to request
(request as any).validated = validated;
next();
} catch (error) {
if (error instanceof z.ZodError) {
return response.status(400).json({
success: false,
message: 'Validation error',
errors: error.errors.map(err => ({
field: err.path.join('.'),
message: err.message
}))
});
}
logger.error({ error }, 'Validation error');
return response.status(500).json({
success: false,
message: 'Internal server error'
});
}
};
}`,
// Auth controller
'src/controllers/auth.controller.ts': `import HyperExpress from 'hyper-express';
import bcrypt from 'bcryptjs';
import jwt from 'jsonwebtoken';
import { prisma } from '../services/database';
import { config } from '../config/config';
import { logger } from '../utils/logger';
import { emailService } from '../services/email.service';
import { cacheService } from '../services/cache.service';
import { generateTokens, verifyRefreshToken } from '../utils/jwt';
export const authController = {
async register(request: HyperExpress.Request, response: HyperExpress.Response) {
try {
const { body } = (request as any).validated;
const { email, password, name } = body;
// Check if user exists
const existingUser = await prisma.user.findUnique({
where: { email }
});
if (existingUser) {
return response.status(400).json({
success: false,
message: 'Email already registered'
});
}
// Hash password
const hashedPassword = await bcrypt.hash(password, 10);
// Create user
const user = await prisma.user.create({
data: {
email,
password: hashedPassword,
name,
verificationToken: generateVerificationToken()
}
});
// Send verification email
await emailService.sendVerificationEmail(user.email, user.verificationToken!);
// Generate tokens
const tokens = generateTokens({
id: user.id,
email: user.email,
role: user.role
});
// Set refresh token in cookie
response.cookie('refreshToken', tokens.refreshToken, {
httpOnly: true,
secure: config.env === 'production',
sameSite: 'lax',
maxAge: 7 * 24 * 60 * 60 * 1000 // 7 days
});
response.status(201).json({
success: true,
message: 'Registration successful',
data: {
user: {
id: user.id,
email: user.email,
name: user.name,
role: user.role
},
accessToken: tokens.accessToken
}
});
} catch (error) {
logger.error({ error }, 'Registration error');
response.status(500).json({
success: false,
message: 'Registration failed'
});
}
},
async login(request: HyperExpress.Request, response: HyperExpress.Response) {
try {
const { body } = (request as any).validated;
const { email, password } = body;
// Find user
const user = await prisma.user.findUnique({
where: { email }
});
if (!user || !await bcrypt.compare(password, user.password)) {
return response.status(401).json({
success: false,
message: 'Invalid credentials'
});
}
if (!user.isActive) {
return response.status(403).json({
success: false,
message: 'Account is deactivated'
});
}
// Update last login
await prisma.user.update({
where: { id: user.id },
data: { lastLogin: new Date() }
});
// Generate tokens
const tokens = generateTokens({
id: user.id,
email: user.email,
role: user.role
});
// Set refresh token in cookie
response.cookie('refreshToken', tokens.refreshToken, {
httpOnly: true,
secure: config.env === 'production',
sameSite: 'lax',
maxAge: 7 * 24 * 60 * 60 * 1000
});
response.json({
success: true,
message: 'Login successful',
data: {
user: {
id: user.id,
email: user.email,
name: user.name,
role: user.role
},
accessToken: tokens.accessToken
}
});
} catch (error) {
logger.error({ error }, 'Login error');
response.status(500).json({
success: false,
message: 'Login failed'
});
}
},
async refreshToken(request: HyperExpress.Request, response: HyperExpress.Response) {
try {
const { body } = (request as any).validated;
const refreshToken = body.refreshToken || request.cookies.refreshToken;
if (!refreshToken) {
return response.status(401).json({
success: false,
message: 'Refresh token required'
});
}
const payload = verifyRefreshToken(refreshToken);
// Check if token is blacklisted
const isBlacklisted = await cacheService.get(\`blacklist:\${refreshToken}\`);
if (isBlacklisted) {
return response.status(401).json({
success: false,
message: 'Invalid refresh token'
});
}
// Generate new access token
const accessToken = jwt.sign(
{
id: payload.id,
email: payload.email,
role: payload.role
},
config.jwt.secret,
{ expiresIn: config.jwt.expiresIn }
);
response.json({
success: true,
data: { accessToken }
});
} catch (error) {
response.status(401).json({
success: false,
message: 'Invalid refresh token'
});
}
},
async logout(request: HyperExpress.Request, response: HyperExpress.Response) {
try {
const refreshToken = request.cookies.refreshToken;
if (refreshToken) {
// Blacklist refresh token
await cacheService.set(
\`blacklist:\${refreshToken}\`,
'1',
7 * 24 * 60 * 60 // 7 days
);
}
// Clear cookie
response.clearCookie('refreshToken');
response.json({
success: true,
message: 'Logout successful'
});
} catch (error) {
logger.error({ error }, 'Logout error');
response.status(500).json({
success: false,
message: 'Logout failed'
});
}
},
async forgotPassword(request: HyperExpress.Request, response: HyperExpress.Response) {
try {
const { body } = (request as any).validated;
const { email } = body;
const user = await prisma.user.findUnique({
where: { email }
});
if (!user) {
// Don't reveal if user exists
return response.json({
success: true,
message: 'If the email exists, a reset link has been sent'
});
}
// Generate reset token
const resetToken = generateResetToken();
const resetTokenExpiry = new Date(Date.now() + 3600000); // 1 hour
await prisma.user.update({
where: { id: user.id },
data: {
resetToken,
resetTokenExpiry
}
});
// Send reset email
await emailService.sendPasswordResetEmail(user.email, resetToken);
response.json({
success: true,
message: 'If the email exists, a reset link has been sent'
});
} catch (error) {
logger.error({ error }, 'Forgot password error');
response.status(500).json({
success: false,
message: 'Failed to process request'
});
}
},
async resetPassword(request: HyperExpress.Request, response: HyperExpress.Response) {
try {
const { body, params } = (request as any).validated;
const { password } = body;
const { token } = params;
const user = await prisma.user.findFirst({
where: {
resetToken: token,
resetTokenExpiry: {
gt: new Date()
}
}
});
if (!user) {
return response.status(400).json({
success: false,
message: 'Invalid or expired reset token'
});
}
// Hash new password
const hashedPassword = await bcrypt.hash(password, 10);
// Update user
await prisma.user.update({
where: { id: user.id },
data: {
password: hashedPassword,
resetToken: null,
resetTokenExpiry: null
}
});
response.json({
success: true,
message: 'Password reset successful'
});
} catch (error) {
logger.error({ error }, 'Reset password error');
response.status(500).json({
success: false,
message: 'Failed to reset password'
});
}
},
async verifyEmail(request: HyperExpress.Request, response: HyperExpress.Response) {
try {
const { token } = request.params;
const user = await prisma.user.findFirst({
where: {
verificationToken: token
}
});
if (!user) {
return response.status(400).json({
success: false,
message: 'Invalid verification token'
});
}
await prisma.user.update({
where: { id: user.id },
data: {
isVerified: true,
verificationToken: null
}
});
response.json({
success: true,
message: 'Email verified successfully'
});
} catch (error) {
logger.error({ error }, 'Email verification error');
response.status(500).json({
success: false,
message: 'Failed to verify email'
});
}
},
async getCurrentUser(request: HyperExpress.Request, response: HyperExpress.Response) {
try {
const userId = request.user!.id;
const user = await prisma.user.findUnique({
where: { id: userId },
select: {
id: true,
email: true,
name: true,
role: true,
avatarUrl: true,
isVerified: true,
createdAt: true,
updatedAt: true
}
});
if (!user) {
return response.status(404).json({
success: false,
message: 'User not found'
});
}
response.json({
success: true,
data: user
});
} catch (error) {
logger.error({ error }, 'Get current user error');
response.status(500).json({
success: false,
message: 'Failed to get user'
});
}
}
};
function generateVerificationToken(): string {
return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
}
function generateResetToken(): string {
return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
}`,
// Auth validators
'src/validators/auth.validator.ts': `import { z } from 'zod';
export const RegisterSchema = z.object({
body: z.object({
email: z.string().email(),
password: z.string().min(8).max(100),
name: z.string().min(1).max(100)
})
});
export const LoginSchema = z.object({
body: z.object({
email: z.string().email(),
password: z.string()
})
});
export const RefreshTokenSchema = z.object({
body: z.object({
refreshToken: z.string().optional()
})
});
export const ForgotPasswordSchema = z.object({
body: z.object({
email: z.string().email()
})
});
export const ResetPasswordSchema = z.object({
body: z.object({
password: z.string().min(8).max(100)
}),
params: z.object({
token: z.string()
})
});`,
// Services initialization
'src/services/index.ts': `import { prisma } from './database';
import { redis } from './redis';
import { logger } from '../utils/logger';
export async function initializeServices() {
try {
// Test database connection
await prisma.$connect();
logger.info('Database connected');
// Test Redis connection
await redis.ping();
logger.info('Redis connected');
// Initialize other services here
} catch (error) {
logger.error({ error }, 'Failed to initialize services');
throw error;
}
}`,
// Database service
'src/services/database.ts': `import { PrismaClient } from '@prisma/client';
import { logger } from '../utils/logger';
export const prisma = new PrismaClient({
log: process.env.NODE_ENV === 'development'
? ['query', 'error', 'warn']
: ['error'],
errorFormat: 'pretty'
});
// Log queries in development
if (process.env.NODE_ENV === 'development') {
prisma.$on('query' as never, (e: any) => {
logger.debug({
query: e.query,
params: e.params,
duration: e.duration
}, 'Database query');
});
}`,
// Redis service
'src/services/redis.ts': `import Redis from 'ioredis';
import { config } from '../config/