create-aziz-app 2.0.13 → 2.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-aziz-app",
-  "version": "2.0.13",
+  "version": "2.0.14",
   "description": "A React-like framework with state management, routing, and API routes - Create apps with auto-import, live reload, and Next.js-like features",
   "keywords": [
     "react",

package/template/api/createUser.js

@@ -0,0 +1,69 @@
+// API Route: /api/createUser
+// Next.js App Router style
+
+const { NextResponse } = require('../modules/next-response');
+
+// Mock database
+let users = [
+    { _id: '1', name: 'Aziz Ahmed', email: 'aziz@example.com', role: 'admin', phone: '123-456-7890' }
+];
+
+// POST handler
+async function POST(request) {
+    try {
+        // Parse request body
+        const body = await request.json();
+        const { name, email, password, role, phone } = body;
+
+        // Validation
+        if (!name || !email || !password) {
+            return NextResponse.json(
+                { 
+                    error: 'Validation failed',
+                    message: 'Name, email, and password are required'
+                },
+                { status: 400 }
+            );
+        }
+
+        // Check if email already exists
+        if (users.find(u => u.email === email)) {
+            return NextResponse.json(
+                { error: 'User with this email already exists' },
+                { status: 409 }
+            );
+        }
+
+        // Create new user
+        const newUser = {
+            _id: String(users.length + 1),
+            name,
+            email,
+            password, // In production, hash this with bcrypt!
+            role: role || 'user',
+            phone: phone || '',
+            createdAt: new Date().toISOString()
+        };
+
+        users.push(newUser);
+
+        // Return user data (without password)
+        const { password: _, ...userData } = newUser;
+
+        return NextResponse.json(
+            {
+                message: 'User created successfully',
+                user: userData
+            },
+            { status: 201 }
+        );
+    } catch (error) {
+        console.error('Create user error:', error);
+        return NextResponse.json(
+            { error: 'Failed to create user' },
+            { status: 500 }
+        );
+    }
+}
+
+module.exports = { POST };

package/template/api/getUser.js

@@ -0,0 +1,60 @@
+// API Route: /api/getUser
+// Next.js App Router style with NextResponse
+
+const { NextResponse } = require('../modules/next-response');
+
+// Mock database
+const users = [
+    { _id: '1', name: 'Aziz Ahmed', email: 'aziz@example.com', role: 'admin', phone: '123-456-7890' },
+    { _id: '2', name: 'John Doe', email: 'john@example.com', role: 'user', phone: '098-765-4321' },
+    { _id: '3', name: 'Jane Smith', email: 'jane@example.com', role: 'user', phone: '555-123-4567' }
+];
+
+// GET handler - Next.js App Router style
+async function GET(request) {
+    try {
+        // Parse URL and get search params
+        const { searchParams } = new URL(request.url);
+        const email = searchParams.get('email');
+        const id = searchParams.get('id');
+
+        // Find by email
+        if (email) {
+            const user = users.find(u => u.email === email);
+            if (!user) {
+                return NextResponse.json(
+                    { error: 'User not found' },
+                    { status: 404 }
+                );
+            }
+            return NextResponse.json(user);
+        }
+
+        // Find by ID
+        if (id) {
+            const user = users.find(u => u._id === id);
+            if (!user) {
+                return NextResponse.json(
+                    { error: 'User not found' },
+                    { status: 404 }
+                );
+            }
+            return NextResponse.json(user);
+        }
+
+        // No params provided
+        return NextResponse.json(
+            { error: 'Email or ID required' },
+            { status: 400 }
+        );
+    } catch (error) {
+        console.error('Error fetching user:', error);
+        return NextResponse.json(
+            { error: 'Failed to fetch user' },
+            { status: 500 }
+        );
+    }
+}
+
+// Export the handler
+module.exports = { GET };

package/template/api/getUserWithDB.js

@@ -0,0 +1,65 @@
+// API Route: /api/getUserWithDB
+// Complete Next.js App Router style with DB and Model
+
+const { NextResponse } = require('../modules/next-response');
+const connectDB = require('../lib/db');
+const User = require('../models/User');
+
+// GET handler - Exactly like Next.js!
+async function GET(request) {
+    try {
+        // Connect to database
+        await connectDB();
+
+        // Parse URL and get search params
+        const { searchParams } = new URL(request.url);
+        const email = searchParams.get('email');
+        const id = searchParams.get('id');
+
+        // Find by email
+        if (email) {
+            const user = await User.findOne({ email });
+            
+            if (!user) {
+                return NextResponse.json(
+                    { error: 'User not found' },
+                    { status: 404 }
+                );
+            }
+
+            // Return user without sensitive fields
+            const { password, ...userData } = user;
+            return NextResponse.json(userData);
+        }
+
+        // Find by ID
+        if (id) {
+            const user = await User.findById(id);
+            
+            if (!user) {
+                return NextResponse.json(
+                    { error: 'User not found' },
+                    { status: 404 }
+                );
+            }
+
+            // Return user without sensitive fields
+            const { password, ...userData } = user;
+            return NextResponse.json(userData);
+        }
+
+        // No params - return error
+        return NextResponse.json(
+            { error: 'Email or ID required' },
+            { status: 400 }
+        );
+    } catch (error) {
+        console.error('Error fetching user:', error);
+        return NextResponse.json(
+            { error: 'Failed to fetch user' },
+            { status: 500 }
+        );
+    }
+}
+
+module.exports = { GET };

package/template/api/loginUser.js

@@ -0,0 +1,61 @@
+// API Route: /api/loginUser
+// Next.js App Router style
+
+const { NextResponse } = require('../modules/next-response');
+
+// Mock database
+const users = [
+    { _id: '1', name: 'Aziz Ahmed', email: 'aziz@example.com', password: 'admin123', role: 'admin' },
+    { _id: '2', name: 'John Doe', email: 'john@example.com', password: 'user123', role: 'user' }
+];
+
+// POST handler
+async function POST(request) {
+    try {
+        // Parse request body
+        const body = await request.json();
+        const { email, password } = body;
+
+        // Validation
+        if (!email || !password) {
+            return NextResponse.json(
+                { error: 'Email and password are required' },
+                { status: 400 }
+            );
+        }
+
+        // Find user
+        const user = users.find(u => u.email === email);
+        
+        if (!user) {
+            return NextResponse.json(
+                { error: 'Invalid credentials' },
+                { status: 401 }
+            );
+        }
+
+        // Check password (in production, use bcrypt!)
+        if (user.password !== password) {
+            return NextResponse.json(
+                { error: 'Invalid credentials' },
+                { status: 401 }
+            );
+        }
+
+        // Return user data (without password)
+        const { password: _, ...userData } = user;
+        
+        return NextResponse.json({
+            ...userData,
+            message: 'Login successful'
+        });
+    } catch (error) {
+        console.error('Login error:', error);
+        return NextResponse.json(
+            { error: 'Failed to login' },
+            { status: 500 }
+        );
+    }
+}
+
+module.exports = { POST };

package/template/docs/NEXTJS-APP-ROUTER.md

@@ -0,0 +1,536 @@
+# Next.js App Router Style API Routes
+
+## Overview
+
+Write API routes **exactly like Next.js App Router** with `NextResponse` and named HTTP method exports!
+
+## Quick Example
+
+```javascript
+// api/getUser.js
+const { NextResponse } = require('../modules/next-response');
+
+export async function GET(request) {
+    const { searchParams } = new URL(request.url);
+    const email = searchParams.get('email');
+    
+    if (!email) {
+        return NextResponse.json(
+            { error: 'Email required' },
+            { status: 400 }
+        );
+    }
+    
+    const user = await findUser(email);
+    return NextResponse.json(user);
+}
+
+module.exports = { GET };
+```
+
+## NextResponse API
+
+### NextResponse.json()
+
+```javascript
+// Success response
+return NextResponse.json({ message: 'Success' });
+
+// With status code
+return NextResponse.json(
+    { error: 'Not found' },
+    { status: 404 }
+);
+
+// With custom headers
+return NextResponse.json(
+    { data: 'value' },
+    { 
+        status: 200,
+        headers: {
+            'X-Custom-Header': 'value'
+        }
+    }
+);
+```
+
+### NextResponse.text()
+
+```javascript
+return NextResponse.text('Hello World');
+
+return NextResponse.text(
+    'Error message',
+    { status: 500 }
+);
+```
+
+### NextResponse.redirect()
+
+```javascript
+return NextResponse.redirect('/login');
+
+return NextResponse.redirect(
+    '/dashboard',
+    { status: 307 }
+);
+```
+
+### NextResponse.error()
+
+```javascript
+return NextResponse.error();
+// Returns 500 with generic error message
+```
+
+## HTTP Method Exports
+
+### Single Method
+
+```javascript
+// api/getUser.js
+const { NextResponse } = require('../modules/next-response');
+
+async function GET(request) {
+    return NextResponse.json({ message: 'GET request' });
+}
+
+module.exports = { GET };
+```
+
+### Multiple Methods
+
+```javascript
+// api/users.js
+const { NextResponse } = require('../modules/next-response');
+
+async function GET(request) {
+    const users = await getAllUsers();
+    return NextResponse.json(users);
+}
+
+async function POST(request) {
+    const body = await request.json();
+    const user = await createUser(body);
+    return NextResponse.json(user, { status: 201 });
+}
+
+async function PUT(request) {
+    const body = await request.json();
+    const user = await updateUser(body);
+    return NextResponse.json(user);
+}
+
+async function DELETE(request) {
+    const { searchParams } = new URL(request.url);
+    const id = searchParams.get('id');
+    await deleteUser(id);
+    return NextResponse.json({ message: 'Deleted' });
+}
+
+module.exports = { GET, POST, PUT, DELETE };
+```
+
+## Request Object
+
+### URL and Search Params
+
+```javascript
+async function GET(request) {
+    // Parse URL
+    const { searchParams } = new URL(request.url);
+    
+    // Get query parameters
+    const email = searchParams.get('email');
+    const id = searchParams.get('id');
+    const page = searchParams.get('page') || '1';
+    
+    return NextResponse.json({ email, id, page });
+}
+```
+
+### Request Body
+
+```javascript
+async function POST(request) {
+    // Parse JSON body
+    const body = await request.json();
+    const { name, email, password } = body;
+    
+    return NextResponse.json({ name, email });
+}
+```
+
+### Headers
+
+```javascript
+async function GET(request) {
+    // Access headers
+    const auth = request.headers.authorization;
+    const contentType = request.headers['content-type'];
+    
+    return NextResponse.json({ auth, contentType });
+}
+```
+
+### Method
+
+```javascript
+async function GET(request) {
+    console.log(request.method); // 'GET'
+    return NextResponse.json({ method: request.method });
+}
+```
+
+## Complete Examples
+
+### Example 1: User Login
+
+```javascript
+// api/loginUser.js
+const { NextResponse } = require('../modules/next-response');
+const connectDB = require('../lib/db');
+const User = require('../models/User');
+
+async function POST(request) {
+    try {
+        await connectDB();
+        
+        const { email, password } = await request.json();
+        
+        // Validation
+        if (!email || !password) {
+            return NextResponse.json(
+                { error: 'Email and password required' },
+                { status: 400 }
+            );
+        }
+        
+        // Find user
+        const user = await User.findOne({ email });
+        if (!user) {
+            return NextResponse.json(
+                { error: 'Invalid credentials' },
+                { status: 401 }
+            );
+        }
+        
+        // Check password (use bcrypt in production!)
+        if (user.password !== password) {
+            return NextResponse.json(
+                { error: 'Invalid credentials' },
+                { status: 401 }
+            );
+        }
+        
+        // Return user data
+        const { password: _, ...userData } = user;
+        return NextResponse.json(userData);
+        
+    } catch (error) {
+        console.error('Login error:', error);
+        return NextResponse.json(
+            { error: 'Failed to login' },
+            { status: 500 }
+        );
+    }
+}
+
+module.exports = { POST };
+```
+
+### Example 2: Create User
+
+```javascript
+// api/createUser.js
+const { NextResponse } = require('../modules/next-response');
+const connectDB = require('../lib/db');
+const User = require('../models/User');
+
+async function POST(request) {
+    try {
+        await connectDB();
+        
+        const body = await request.json();
+        const { name, email, password, role, phone } = body;
+        
+        // Validation
+        if (!name || !email || !password) {
+            return NextResponse.json(
+                { error: 'Name, email, and password required' },
+                { status: 400 }
+            );
+        }
+        
+        // Check if exists
+        const existing = await User.findOne({ email });
+        if (existing) {
+            return NextResponse.json(
+                { error: 'User already exists' },
+                { status: 409 }
+            );
+        }
+        
+        // Create user
+        const user = await User.create({
+            name,
+            email,
+            password, // Hash with bcrypt in production!
+            role: role || 'user',
+            phone
+        });
+        
+        // Return without password
+        const { password: _, ...userData } = user;
+        return NextResponse.json(
+            { message: 'User created', user: userData },
+            { status: 201 }
+        );
+        
+    } catch (error) {
+        console.error('Create user error:', error);
+        return NextResponse.json(
+            { error: 'Failed to create user' },
+            { status: 500 }
+        );
+    }
+}
+
+module.exports = { POST };
+```
+
+### Example 3: Get User
+
+```javascript
+// api/getUser.js
+const { NextResponse } = require('../modules/next-response');
+const connectDB = require('../lib/db');
+const User = require('../models/User');
+
+async function GET(request) {
+    try {
+        await connectDB();
+        
+        const { searchParams } = new URL(request.url);
+        const email = searchParams.get('email');
+        const id = searchParams.get('id');
+        
+        if (email) {
+            const user = await User.findOne({ email });
+            if (!user) {
+                return NextResponse.json(
+                    { error: 'User not found' },
+                    { status: 404 }
+                );
+            }
+            return NextResponse.json(user);
+        }
+        
+        if (id) {
+            const user = await User.findById(id);
+            if (!user) {
+                return NextResponse.json(
+                    { error: 'User not found' },
+                    { status: 404 }
+                );
+            }
+            return NextResponse.json(user);
+        }
+        
+        return NextResponse.json(
+            { error: 'Email or ID required' },
+            { status: 400 }
+        );
+        
+    } catch (error) {
+        console.error('Error:', error);
+        return NextResponse.json(
+            { error: 'Failed to fetch user' },
+            { status: 500 }
+        );
+    }
+}
+
+module.exports = { GET };
+```
+
+## Client-Side Usage
+
+### Basic Fetch
+
+```javascript
+async function LoginUser(email, password) {
+    try {
+        const response = await fetch('/api/loginUser', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ email, password })
+        });
+        
+        const result = await response.json();
+        
+        if (!response.ok) {
+            throw new Error(result.error);
+        }
+        
+        return result;
+    } catch (error) {
+        console.error('Login failed:', error);
+        throw error;
+    }
+}
+```
+
+### With React Hooks
+
+```javascript
+function LoginForm() {
+    const [email, setEmail] = useState('');
+    const [password, setPassword] = useState('');
+    const [error, setError] = useState('');
+    const [loading, setLoading] = useState(false);
+    
+    const handleLogin = async (e) => {
+        e.preventDefault();
+        setLoading(true);
+        setError('');
+        
+        try {
+            const response = await fetch('/api/loginUser', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ email, password })
+            });
+            
+            const result = await response.json();
+            
+            if (!response.ok) {
+                setError(result.error);
+                return;
+            }
+            
+            // Success!
+            localStorage.setItem('user', JSON.stringify(result));
+            window.location.href = '/dashboard';
+            
+        } catch (err) {
+            setError('Failed to login');
+        } finally {
+            setLoading(false);
+        }
+    };
+    
+    return (
+        <form onSubmit={handleLogin}>
+            <input 
+                type="email"
+                value={email}
+                onChange={(e) => setEmail(e.target.value)}
+                placeholder="Email"
+            />
+            <input 
+                type="password"
+                value={password}
+                onChange={(e) => setPassword(e.target.value)}
+                placeholder="Password"
+            />
+            {error && <p style={{ color: 'red' }}>{error}</p>}
+            <button type="submit" disabled={loading}>
+                {loading ? 'Loading...' : 'Login'}
+            </button>
+        </form>
+    );
+}
+```
+
+## Database Integration
+
+### Setup (MongoDB Example)
+
+```bash
+npm install mongoose
+```
+
+```javascript
+// lib/db.js
+const mongoose = require('mongoose');
+
+async function connectDB() {
+    if (mongoose.connections[0].readyState) {
+        return;
+    }
+    
+    await mongoose.connect(process.env.MONGODB_URI);
+    console.log('✅ MongoDB connected');
+}
+
+module.exports = connectDB;
+```
+
+### Model (Mongoose Example)
+
+```javascript
+// models/User.js
+const mongoose = require('mongoose');
+
+const userSchema = new mongoose.Schema({
+    name: { type: String, required: true },
+    email: { type: String, required: true, unique: true },
+    password: { type: String, required: true },
+    role: { type: String, enum: ['user', 'admin'], default: 'user' },
+    phone: String
+}, { timestamps: true });
+
+module.exports = mongoose.models.User || mongoose.model('User', userSchema);
+```
+
+## Environment Variables
+
+```bash
+# .env.local
+MONGODB_URI=mongodb://localhost:27017/myapp
+DATABASE_URL=postgresql://user:pass@localhost:5432/mydb
+API_KEY=your_secret_key
+```
+
+```javascript
+// Access in API routes
+const dbUrl = process.env.MONGODB_URI;
+const apiKey = process.env.API_KEY;
+```
+
+## Migration from Old Style
+
+### Old Style
+
+```javascript
+export default async function handler(req, res) {
+    if (req.method === 'GET') {
+        return res.status(200).json({ data: 'value' });
+    }
+}
+```
+
+### New Style
+
+```javascript
+const { NextResponse } = require('../modules/next-response');
+
+async function GET(request) {
+    return NextResponse.json({ data: 'value' });
+}
+
+module.exports = { GET };
+```
+
+## Summary
+
+✅ **Identical to Next.js App Router**
+✅ **NextResponse API**
+✅ **Named HTTP method exports**
+✅ **URL and search params**
+✅ **Request body parsing**
+✅ **Database integration ready**
+✅ **Easy migration path**
+
+Write your APIs exactly like Next.js! 🎉

package/template/lib/db.js

@@ -0,0 +1,67 @@
+// Database connection helper
+// This is a mock - replace with real database connection
+
+let isConnected = false;
+
+async function connectDB() {
+    if (isConnected) {
+        console.log('✅ Using existing database connection');
+        return;
+    }
+
+    try {
+        // In production, connect to real database here:
+        // await mongoose.connect(process.env.MONGODB_URI);
+        // or
+        // db = await new Database(process.env.DATABASE_URL);
+        
+        console.log('✅ Database connected (mock)');
+        isConnected = true;
+    } catch (error) {
+        console.error('❌ Database connection failed:', error);
+        throw error;
+    }
+}
+
+module.exports = connectDB;
+
+// Example usage with MongoDB:
+/*
+const mongoose = require('mongoose');
+
+async function connectDB() {
+    if (mongoose.connections[0].readyState) {
+        return;
+    }
+
+    await mongoose.connect(process.env.MONGODB_URI, {
+        useNewUrlParser: true,
+        useUnifiedTopology: true,
+    });
+    
+    console.log('✅ MongoDB connected');
+}
+
+module.exports = connectDB;
+*/
+
+// Example usage with PostgreSQL:
+/*
+const { Pool } = require('pg');
+
+const pool = new Pool({
+    connectionString: process.env.DATABASE_URL,
+});
+
+async function connectDB() {
+    try {
+        await pool.query('SELECT NOW()');
+        console.log('✅ PostgreSQL connected');
+    } catch (error) {
+        console.error('❌ PostgreSQL connection failed:', error);
+        throw error;
+    }
+}
+
+module.exports = connectDB;
+*/

package/template/models/User.js

@@ -0,0 +1,102 @@
+// User Model
+// This is a mock - replace with real database model
+
+// Mock in-memory database
+let users = [
+    { _id: '1', name: 'Aziz Ahmed', email: 'aziz@example.com', role: 'admin', phone: '123-456-7890' },
+    { _id: '2', name: 'John Doe', email: 'john@example.com', role: 'user', phone: '098-765-4321' }
+];
+
+class User {
+    // Find one user
+    static async findOne(query) {
+        const user = users.find(u => {
+            return Object.keys(query).every(key => u[key] === query[key]);
+        });
+        return user || null;
+    }
+
+    // Find by ID
+    static async findById(id) {
+        return users.find(u => u._id === id) || null;
+    }
+
+    // Find all users
+    static async find(query = {}) {
+        if (Object.keys(query).length === 0) {
+            return users;
+        }
+        return users.filter(u => {
+            return Object.keys(query).every(key => u[key] === query[key]);
+        });
+    }
+
+    // Create new user
+    static async create(userData) {
+        const newUser = {
+            _id: String(users.length + 1),
+            ...userData,
+            createdAt: new Date().toISOString()
+        };
+        users.push(newUser);
+        return newUser;
+    }
+
+    // Update user
+    static async findByIdAndUpdate(id, updates) {
+        const index = users.findIndex(u => u._id === id);
+        if (index === -1) return null;
+        
+        users[index] = { ...users[index], ...updates, updatedAt: new Date().toISOString() };
+        return users[index];
+    }
+
+    // Delete user
+    static async findByIdAndDelete(id) {
+        const index = users.findIndex(u => u._id === id);
+        if (index === -1) return null;
+        
+        const deleted = users.splice(index, 1)[0];
+        return deleted;
+    }
+
+    // Select specific fields
+    select(fields) {
+        // This is a chainable method for field selection
+        // In real Mongoose, this would be: User.findOne().select('name email')
+        return this;
+    }
+}
+
+module.exports = User;
+
+// Example usage with Mongoose:
+/*
+const mongoose = require('mongoose');
+
+const userSchema = new mongoose.Schema({
+    name: {
+        type: String,
+        required: true
+    },
+    email: {
+        type: String,
+        required: true,
+        unique: true
+    },
+    password: {
+        type: String,
+        required: true
+    },
+    role: {
+        type: String,
+        enum: ['user', 'admin'],
+        default: 'user'
+    },
+    phone: String
+}, {
+    timestamps: true
+});
+
+module.exports = mongoose.models.User || mongoose.model('User', userSchema);
+*/

package/template/modules/next-response.js

@@ -0,0 +1,58 @@
+// NextResponse - Next.js-compatible response helper
+class NextResponse {
+    constructor(body, init = {}) {
+        this.body = body;
+        this.status = init.status || 200;
+        this.headers = new Map(Object.entries(init.headers || {}));
+    }
+
+    static json(data, init = {}) {
+        return new NextResponse(JSON.stringify(data), {
+            ...init,
+            headers: {
+                'Content-Type': 'application/json',
+                ...(init.headers || {})
+            }
+        });
+    }
+
+    static text(text, init = {}) {
+        return new NextResponse(text, {
+            ...init,
+            headers: {
+                'Content-Type': 'text/plain',
+                ...(init.headers || {})
+            }
+        });
+    }
+
+    static redirect(url, init = {}) {
+        return new NextResponse(null, {
+            ...init,
+            status: init.status || 307,
+            headers: {
+                'Location': url,
+                ...(init.headers || {})
+            }
+        });
+    }
+
+    static error() {
+        return new NextResponse(JSON.stringify({ error: 'Internal Server Error' }), {
+            status: 500,
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+}
+
+// Export for Node.js (server-side)
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = { NextResponse };
+}
+
+// Export for browser (if needed)
+if (typeof window !== 'undefined') {
+    window.NextResponse = NextResponse;
+}

package/template/scripts/dev-server.js

@@ -30,17 +30,34 @@ function loadApiRoutes() {
             // Clear require cache to allow hot reload
             delete require.cache[require.resolve(filePath)];
             
-            // Load the API handler
+            // Load the API module
             const module = require(filePath);
             
-            // Support both default export and module.exports
-            const handler = module.default || module;
+            // Support both styles:
+            // 1. Default export function (old style)
+            // 2. Named exports: GET, POST, PUT, DELETE (new Next.js App Router style)
             
-            if (typeof handler === 'function') {
-                apiHandlers[routeName] = handler;
-                console.log(`   ✅ /api/${routeName}`);
+            if (module.GET || module.POST || module.PUT || module.DELETE || module.PATCH) {
+                // New style: Named exports
+                const methods = {};
+                if (module.GET) methods.GET = module.GET;
+                if (module.POST) methods.POST = module.POST;
+                if (module.PUT) methods.PUT = module.PUT;
+                if (module.DELETE) methods.DELETE = module.DELETE;
+                if (module.PATCH) methods.PATCH = module.PATCH;
+                
+                apiHandlers[routeName] = methods;
+                console.log(`   ✅ /api/${routeName} [${Object.keys(methods).join(', ')}]`);
             } else {
-                console.log(`   ⚠️  /api/${routeName} - No handler function exported`);
+                // Old style: Default export
+                const handler = module.default || module;
+                
+                if (typeof handler === 'function') {
+                    apiHandlers[routeName] = handler;
+                    console.log(`   ✅ /api/${routeName}`);
+                } else {
+                    console.log(`   ⚠️  /api/${routeName} - No handler function exported`);
+                }
             }
         } catch (error) {
             console.error(`   ❌ /api/${routeName} - ${error.message}`);
@@ -49,6 +66,7 @@ function loadApiRoutes() {
     
     console.log('');
 }
+}
 
 // Parse request body
 function parseBody(req) {
@@ -103,48 +121,91 @@ async function handleApiRequest(req, res) {
         const body = await parseBody(req);
         const query = parseQuery(req.url);
         
-        // Create Next.js-like req/res objects
-        const apiReq = {
-            method: req.method,
-            body: body,
-            query: query,
-            headers: req.headers,
-            url: req.url
-        };
-
-        const apiRes = {
-            statusCode: 200,
-            headers: {},
-            status(code) {
-                this.statusCode = code;
-                return this;
-            },
-            json(data) {
-                res.writeHead(this.statusCode, {
+        // Check if handler is a function (old style) or object with HTTP methods (new style)
+        let result;
+        
+        if (typeof handler === 'function') {
+            // Old style: default export function
+            const apiReq = {
+                method: req.method,
+                body: body,
+                query: query,
+                headers: req.headers,
+                url: req.url
+            };
+
+            const apiRes = {
+                statusCode: 200,
+                headers: {},
+                status(code) {
+                    this.statusCode = code;
+                    return this;
+                },
+                json(data) {
+                    res.writeHead(this.statusCode, {
+                        'Content-Type': 'application/json',
+                        'Access-Control-Allow-Origin': '*',
+                        ...this.headers
+                    });
+                    res.end(JSON.stringify(data));
+                    return this;
+                },
+                send(data) {
+                    res.writeHead(this.statusCode, {
+                        'Content-Type': 'text/plain',
+                        'Access-Control-Allow-Origin': '*',
+                        ...this.headers
+                    });
+                    res.end(data);
+                    return this;
+                },
+                setHeader(key, value) {
+                    this.headers[key] = value;
+                    return this;
+                }
+            };
+
+            await handler(apiReq, apiRes);
+        } else if (typeof handler === 'object') {
+            // New style: Named exports (GET, POST, PUT, DELETE)
+            const methodHandler = handler[req.method];
+            
+            if (!methodHandler) {
+                res.writeHead(405, { 
                     'Content-Type': 'application/json',
-                    'Access-Control-Allow-Origin': '*',
-                    ...this.headers
-                });
-                res.end(JSON.stringify(data));
-                return this;
-            },
-            send(data) {
-                res.writeHead(this.statusCode, {
-                    'Content-Type': 'text/plain',
-                    'Access-Control-Allow-Origin': '*',
-                    ...this.headers
+                    'Allow': Object.keys(handler).join(', ')
                 });
-                res.end(data);
-                return this;
-            },
-            setHeader(key, value) {
-                this.headers[key] = value;
-                return this;
+                res.end(JSON.stringify({ 
+                    error: 'Method not allowed',
+                    allowedMethods: Object.keys(handler)
+                }));
+                return;
             }
-        };
 
-        // Call the handler
-        await handler(apiReq, apiRes);
+            // Create Next.js-style request object
+            const request = {
+                method: req.method,
+                headers: req.headers,
+                url: `http://localhost:${PORT}${req.url}`,
+                json: async () => body,
+                text: async () => typeof body === 'string' ? body : JSON.stringify(body)
+            };
+
+            // Call the handler
+            result = await methodHandler(request);
+
+            // Handle NextResponse
+            if (result && result.body !== undefined) {
+                const statusCode = result.status || 200;
+                const headers = {
+                    'Access-Control-Allow-Origin': '*',
+                    ...Object.fromEntries(result.headers || [])
+                };
+                
+                res.writeHead(statusCode, headers);
+                res.end(result.body);
+            }
+        }
         
     } catch (error) {
         console.error(`❌ API Error on /api/${routeName}:`, error);