@misterzik/espressojs 3.3.4 → 3.3.6

package/CHANGELOG.md

@@ -2,6 +2,89 @@
 
 All notable changes to EspressoJS will be documented in this file.
 
+## [3.3.6] - 2024-12-25
+
+### Fixed
+- **Critical**: API routes now load correctly from `routes/api/index.js`
+- API routes properly mounted at root level to support `/v1/` endpoints
+- Catch-all route moved to end to prevent intercepting API routes
+- Route loading path corrected to use proper file structure
+- Programmatic usage now properly supported with exported `startServer()` function
+
+### Changed
+- Replaced static version badge with dynamic npm version shield badge
+- Updated landing page to show live npm version from shields.io
+- Improved code formatting and whitespace consistency in HTML files
+- Updated default API URI to use swapi.info instead of swapi.dev
+- Enhanced module exports for better programmatic usage
+
+### Added
+- Dynamic version badge using shields.io npm API
+- Better visual indication of current package version on landing page
+- Exported `startServer()` function for programmatic usage
+- Exported `gracefulShutdown()` function for custom shutdown handling
+- Exported `server` instance for advanced use cases
+- Comprehensive usage patterns documentation (docs/USAGE-PATTERNS.md)
+- README section explaining different server startup methods
+
+### Documentation
+- Added detailed guide explaining why some users need manual `app.listen()`
+- Documented three usage patterns: CLI, Direct Execution, and Programmatic
+- Explained `require.main === module` behavior and implications
+- Migration guide from manual listen to `startServer()` function
+
+## [3.3.5] - 2024-12-25
+
+### Fixed
+- **Critical**: CLI process management - added `process.stdin.resume()` to keep parent process alive
+- Server now stays running properly when using `node cli run`
+- Event loop properly maintained for child process management
+
+### Added
+- Comprehensive CLI usage documentation (docs/CLI-USAGE.md)
+- `start:watch` npm script for auto-restart with nodemon
+- `dev:watch` npm script for development with auto-restart
+- `validate` npm script for configuration validation
+- Detailed process management documentation
+
+### Changed
+- Enhanced signal handling (SIGINT/SIGTERM) for graceful shutdown
+- Improved CLI process lifecycle management
+- Updated README with npm scripts section and process management explanation
+
+### Dependencies
+- Added nodemon ^3.0.2 as devDependency for development auto-restart
+
+## [3.3.4] - 2024-12-24
+
+### Added
+- Modern landing page UI with gradient background and glassmorphism design
+- Feature showcase grid with 6 interactive cards
+- Animated coffee icon with floating effect
+- Call-to-action buttons for GitHub and npm
+- Version badge display on landing page
+- Responsive design for mobile and tablet devices
+- Comprehensive CLI usage documentation (docs/CLI-USAGE.md)
+- `start:watch` and `dev:watch` npm scripts for auto-restart with nodemon
+- `validate` npm script for config validation
+
+### Changed
+- Completely redesigned public/index.html with modern aesthetics
+- Enhanced CLI output with emoji indicators and cleaner formatting
+- Improved CLI startup banner with better information display
+- Updated demo/public/index.html to match new design
+- Updated demo/config.json with new schema (publicDirectory, timeout, retries)
+- Updated demo/espresso.js to use APIManager instead of direct axios
+
+### Fixed
+- **Critical**: CLI process now stays alive after spawning server using `process.stdin.resume()`
+- Server startup process properly maintains event loop
+- Better signal handling (SIGINT/SIGTERM) for graceful shutdown
+- CLI no longer exits prematurely when running `node cli run`
+
+### Dependencies
+- Added nodemon ^3.0.2 as devDependency for development auto-restart
+
 ## [3.3.3] - 2024-12-24
 
 ### Fixed

package/README.md

@@ -93,6 +93,8 @@ require('@misterzik/espressojs/cli');
 
 ### 5. Run Your Server
 
+**Method 1: Using CLI (Recommended)**
+
 ```bash
 # Using the CLI
 node cli run
@@ -101,6 +103,31 @@ node cli run
 npm start
 ```
 
+**Method 2: Direct Execution**
+
+```bash
+node index.js
+```
+
+**Method 3: Programmatic Usage (v3.3.6+)**
+
+If you're requiring EspressoJS as a module in your own code:
+
+```javascript
+// Option A: Use built-in startServer (recommended)
+const { startServer } = require('@misterzik/espressojs');
+startServer();
+
+// Option B: Manual control
+const app = require('@misterzik/espressojs');
+const config = require('@misterzik/espressojs/server');
+app.listen(config.port, () => {
+  console.log(`Server running on port ${config.port}`);
+});
+```
+
+> **Note:** If you're using EspressoJS programmatically (requiring it as a module), the server won't auto-start. You must either call `startServer()` or manually use `app.listen()`. See [Usage Patterns Guide](./docs/USAGE-PATTERNS.md) for details.
+
 ## 🛠️ CLI Commands
 
 EspressoJS comes with a powerful CLI for managing your application:
@@ -112,9 +139,15 @@ node cli show
 # Run the server
 node cli run
 
+# Run with auto-restart (development)
+npm run start:watch
+
 # Update environment settings
 node cli env --instance=production --port=3000
 
+# Validate configuration
+node cli validate
+
 # Initialize new config
 node cli init
 
@@ -128,6 +161,37 @@ node cli version
 node cli --help
 ```
 
+### npm Scripts
+
+EspressoJS provides convenient npm scripts for common tasks:
+
+```bash
+# Start server
+npm start                    # Start with current config
+npm run start:watch          # Start with auto-restart (nodemon)
+
+# Development
+npm run dev                  # Start in development mode
+npm run dev:watch            # Dev mode with auto-restart
+
+# Production
+npm run prod                 # Start in production mode
+
+# Configuration
+npm run show                 # Display current config
+npm run validate             # Validate config.json
+```
+
+**Process Management:**
+
+The CLI uses a parent-child process model to keep your server running:
+- Parent process (CLI) manages the server lifecycle
+- Child process runs the Express application
+- `process.stdin.resume()` keeps the event loop active
+- Press `CTRL+C` for graceful shutdown
+
+For more details, see [CLI Usage Documentation](./docs/CLI-USAGE.md).
+
 ## 📁 Project Structure
 
 ```

package/config.json

@@ -2,6 +2,7 @@
   "instance": "development",
   "port": 8080,
   "hostname": "",
+  "publicDirectory": "/public",
   "mongoDB": {
     "enabled": false,
     "port": null,
@@ -10,11 +11,13 @@
   },
   "api": {
     "enabled": false,
-    "uri": "https://swapi.dev/api/people/",
+    "uri": "https://swapi.info/api",
     "url": "",
     "method": "GET",
     "headers": {
       "Content-Type": "application/json"
-    }
+    },
+    "timeout": 30000,
+    "retries": 0
   }
 }

package/docs/CLI-USAGE.md

@@ -0,0 +1,369 @@
+# EspressoJS CLI Usage Guide
+
+## Overview
+
+The EspressoJS CLI provides a powerful command-line interface for managing your Express server. This guide covers all available commands and best practices.
+
+## Installation
+
+```bash
+npm install @misterzik/espressojs
+```
+
+## Available Commands
+
+### `run` - Start the Server
+
+Starts the Express server with the current configuration.
+
+```bash
+node cli run
+```
+
+**How it works:**
+- The CLI spawns a child process running `index.js`
+- The parent CLI process stays alive to manage the child
+- Press `CTRL+C` to gracefully shut down the server
+
+**npm scripts:**
+```bash
+npm start              # Start with current config
+npm run start:watch    # Start with auto-restart on file changes (nodemon)
+```
+
+### `show` - Display Configuration
+
+Shows the current configuration from `config.json`.
+
+```bash
+node cli show
+```
+
+### `env` - Update Environment Settings
+
+Modify the instance type or port number.
+
+```bash
+# Change instance
+node cli env --instance=production
+
+# Change port
+node cli env --port=3000
+
+# Change both
+node cli env --instance=production --port=3000
+```
+
+### `validate` - Validate Configuration
+
+Validates your `config.json` against the schema.
+
+```bash
+node cli validate
+```
+
+### `init` - Initialize Configuration
+
+Creates a new `config.json` file with default settings.
+
+```bash
+node cli init
+
+# Force overwrite existing config
+node cli init --force
+```
+
+### `version` - Show Version
+
+Displays the EspressoJS version.
+
+```bash
+node cli version
+```
+
+## Process Management
+
+### Why the CLI Stays Alive
+
+The CLI uses a parent-child process model:
+
+1. **Parent Process (CLI)**: Manages the server lifecycle
+2. **Child Process (Server)**: Runs the Express application
+
+The parent process must stay alive to:
+- Keep the child process running
+- Handle graceful shutdown signals
+- Monitor server health
+- Provide process management
+
+**Technical Implementation:**
+```javascript
+// The CLI keeps the process alive using:
+process.stdin.resume();  // Prevents event loop from exiting
+
+// Signal handlers ensure graceful shutdown:
+process.on('SIGINT', () => {
+  child.kill('SIGINT');
+});
+```
+
+### Development vs Production
+
+**Development (with auto-restart):**
+```bash
+npm run dev:watch
+# or
+npm run start:watch
+```
+
+Uses `nodemon` to automatically restart the server when files change.
+
+**Production (stable):**
+```bash
+npm start
+# or
+node cli run
+```
+
+Runs the server without auto-restart for stability.
+
+## npm Scripts Reference
+
+| Script | Command | Description |
+|--------|---------|-------------|
+| `start` | `node cli run` | Start server with current config |
+| `start:watch` | `nodemon cli run` | Start with auto-restart |
+| `dev` | Set dev config + run | Start in development mode |
+| `dev:watch` | Set dev config + nodemon | Dev mode with auto-restart |
+| `global` | Set global config + run | Start in global mode |
+| `prod` | Set prod config + run | Start in production mode |
+| `show` | `node cli show` | Display configuration |
+| `validate` | `node cli validate` | Validate config.json |
+
+## Troubleshooting
+
+### Server Exits Immediately
+
+**Problem:** Server starts but exits right away.
+
+**Solution:** This is now fixed in v3.3.4+. The CLI uses `process.stdin.resume()` to keep the process alive.
+
+**If still experiencing issues:**
+```bash
+# Option 1: Use nodemon
+npm run start:watch
+
+# Option 2: Run server directly (bypasses CLI)
+node index.js
+```
+
+### Port Already in Use
+
+**Problem:** `EADDRINUSE` error.
+
+**Solution:**
+```bash
+# Change the port
+node cli env --port=3001
+node cli run
+```
+
+### Configuration Not Found
+
+**Problem:** `config.json` missing.
+
+**Solution:**
+```bash
+# Create new config
+node cli init
+```
+
+### Process Won't Stop
+
+**Problem:** Server doesn't respond to `CTRL+C`.
+
+**Solution:**
+```bash
+# Force kill (find process ID first)
+ps aux | grep node
+kill -9 <PID>
+
+# Or on Windows
+tasklist | findstr node
+taskkill /F /PID <PID>
+```
+
+## Best Practices
+
+### 1. Use npm Scripts
+
+Instead of running CLI commands directly, use npm scripts:
+
+```bash
+# Good
+npm start
+
+# Also good, but more verbose
+node cli run
+```
+
+### 2. Development Workflow
+
+```bash
+# Initial setup
+npm install
+node cli init
+
+# Start development
+npm run dev:watch
+
+# Test production config
+npm run prod
+```
+
+### 3. Environment-Specific Configs
+
+Create separate config files:
+- `config.development.json`
+- `config.production.json`
+- `config.test.json`
+
+Load them based on `NODE_ENV`:
+```javascript
+const env = process.env.NODE_ENV || 'development';
+const config = require(`./config.${env}.json`);
+```
+
+### 4. Process Managers for Production
+
+For production deployments, use a process manager:
+
+**PM2:**
+```bash
+npm install -g pm2
+pm2 start cli.js --name "espresso-app" -- run
+pm2 save
+pm2 startup
+```
+
+**Forever:**
+```bash
+npm install -g forever
+forever start cli.js run
+```
+
+**Docker:**
+```dockerfile
+FROM node:18-alpine
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --only=production
+COPY . .
+CMD ["node", "cli", "run"]
+```
+
+## Advanced Usage
+
+### Custom CLI Scripts
+
+You can extend the CLI in your own project:
+
+```javascript
+// custom-cli.js
+const { spawn } = require('child_process');
+
+// Custom command
+if (process.argv[2] === 'custom') {
+  console.log('Running custom command...');
+  // Your custom logic
+}
+
+// Fall back to EspressoJS CLI
+require('@misterzik/espressojs/cli');
+```
+
+### Programmatic Usage
+
+Use EspressoJS programmatically without the CLI:
+
+```javascript
+const app = require('@misterzik/espressojs');
+const config = require('@misterzik/espressojs/server');
+
+// Your custom setup
+app.use('/custom', (req, res) => {
+  res.json({ message: 'Custom route' });
+});
+
+// Start server
+const PORT = config.port || 3000;
+app.listen(PORT, () => {
+  console.log(`Server running on port ${PORT}`);
+});
+```
+
+## Signal Handling
+
+The CLI properly handles system signals:
+
+| Signal | Behavior |
+|--------|----------|
+| `SIGINT` | Graceful shutdown (CTRL+C) |
+| `SIGTERM` | Graceful shutdown (kill command) |
+| `SIGKILL` | Immediate termination (cannot be caught) |
+
+**Graceful Shutdown Process:**
+1. Signal received by CLI
+2. CLI forwards signal to child process
+3. Server closes HTTP connections
+4. MongoDB connections closed (if enabled)
+5. Process exits with appropriate code
+
+## FAQ
+
+**Q: Why use the CLI instead of running `index.js` directly?**
+
+A: The CLI provides:
+- Configuration management
+- Environment switching
+- Validation
+- Better error messages
+- Process management
+
+**Q: Can I use the CLI in production?**
+
+A: Yes, but consider using a process manager (PM2, Forever) for:
+- Auto-restart on crashes
+- Load balancing
+- Log management
+- Monitoring
+
+**Q: Does the CLI work on Windows?**
+
+A: Yes, the CLI is cross-platform and works on Windows, macOS, and Linux.
+
+**Q: How do I debug the CLI?**
+
+A: Use Node.js debugging:
+```bash
+node --inspect cli run
+```
+
+Then open Chrome DevTools at `chrome://inspect`.
+
+## Support
+
+- **GitHub Issues**: https://github.com/misterzik/Espresso.js/issues
+- **npm Package**: https://www.npmjs.com/package/@misterzik/espressojs
+- **Documentation**: https://github.com/misterzik/Espresso.js
+
+## Version History
+
+- **v3.3.4**: Fixed CLI process management with `process.stdin.resume()`
+- **v3.3.3**: Enhanced CLI output with emoji indicators
+- **v3.3.2**: Improved error handling
+- **v3.3.1**: Added multiple API support
+
+---
+
+**Happy coding with EspressoJS!** ☕

package/docs/USAGE-PATTERNS.md

@@ -0,0 +1,429 @@
+# EspressoJS Usage Patterns
+
+This guide explains the different ways to use EspressoJS and why some users need to manually call `app.listen()`.
+
+## 📖 Table of Contents
+
+- [Understanding the Issue](#understanding-the-issue)
+- [Usage Pattern 1: CLI (Recommended)](#usage-pattern-1-cli-recommended)
+- [Usage Pattern 2: Direct Execution](#usage-pattern-2-direct-execution)
+- [Usage Pattern 3: Programmatic Usage](#usage-pattern-3-programmatic-usage)
+- [Usage Pattern 4: Custom Entry Point](#usage-pattern-4-custom-entry-point)
+- [Troubleshooting](#troubleshooting)
+
+## Understanding the Issue
+
+EspressoJS uses a conditional check to automatically start the server:
+
+```javascript
+if (require.main === module) {
+  startServer();
+}
+```
+
+**This check determines:**
+- `true` = File is run directly → Server auto-starts
+- `false` = File is required as module → Server does NOT auto-start
+
+**When users report needing to add `app.listen()`:**
+- They're using EspressoJS programmatically (Pattern 3 or 4)
+- The `require.main === module` check is `false`
+- The server doesn't auto-start
+- They must manually start it
+
+## Usage Pattern 1: CLI (Recommended)
+
+**Best for:** Production deployments, standard usage
+
+### Setup
+
+```javascript
+// cli.js
+require('@misterzik/espressojs/cli');
+```
+
+```javascript
+// index.js or espresso.js
+require('@misterzik/espressojs');
+```
+
+### Run
+
+```bash
+node cli run
+# or
+npm start
+```
+
+### How It Works
+
+1. CLI spawns: `node index.js`
+2. `require.main === module` is `true`
+3. Server auto-starts via `startServer()`
+4. CLI keeps process alive
+
+**✅ Advantages:**
+- Automatic server startup
+- Process management handled
+- Configuration commands available
+- Graceful shutdown built-in
+
+**❌ Disadvantages:**
+- Extra CLI layer
+- Slightly more complex setup
+
+## Usage Pattern 2: Direct Execution
+
+**Best for:** Simple deployments, quick testing
+
+### Setup
+
+```javascript
+// index.js
+require('@misterzik/espressojs');
+```
+
+### Run
+
+```bash
+node index.js
+```
+
+### How It Works
+
+1. Node runs `index.js` directly
+2. `require.main === module` is `true`
+3. Server auto-starts
+
+**✅ Advantages:**
+- Simple and direct
+- No CLI needed
+- Automatic startup
+
+**❌ Disadvantages:**
+- No CLI commands
+- Manual configuration management
+
+## Usage Pattern 3: Programmatic Usage
+
+**Best for:** Custom applications, advanced integrations
+
+### Setup (OLD - Requires Manual Listen)
+
+```javascript
+// server.js
+const app = require('@misterzik/espressojs');
+const config = require('@misterzik/espressojs/server');
+
+// require.main === module is FALSE
+// Server does NOT auto-start
+// Must manually start:
+app.listen(config.port, () => {
+  console.log(`Server running on port ${config.port}`);
+});
+```
+
+### Setup (NEW - v3.3.6+ - Use startServer)
+
+```javascript
+// server.js
+const { startServer } = require('@misterzik/espressojs');
+
+// Use the exported startServer function
+startServer();
+```
+
+### How It Works
+
+**OLD Method:**
+1. User requires EspressoJS as module
+2. `require.main === module` is `false`
+3. Server doesn't auto-start
+4. User must call `app.listen()` manually
+
+**NEW Method (v3.3.6+):**
+1. User requires EspressoJS
+2. Calls exported `startServer()` function
+3. Server starts with all built-in features
+4. Graceful shutdown and error handling included
+
+**✅ Advantages:**
+- Full control over server lifecycle
+- Can add custom middleware before starting
+- Integration with existing apps
+
+**❌ Disadvantages:**
+- More code required
+- Must understand module system
+
+## Usage Pattern 4: Custom Entry Point
+
+**Best for:** Complex applications, microservices
+
+### Setup
+
+```javascript
+// app.js (custom entry point)
+const express = require('@misterzik/espressojs');
+const { apiManager, config, startServer } = require('@misterzik/espressojs');
+
+// Add custom middleware
+express.use('/custom', (req, res) => {
+  res.json({ message: 'Custom route' });
+});
+
+// Add custom error handling
+express.use((err, req, res, next) => {
+  console.error('Custom error handler:', err);
+  res.status(500).json({ error: err.message });
+});
+
+// Start server with built-in features
+startServer();
+```
+
+### Alternative: Manual Control
+
+```javascript
+// app.js (full manual control)
+const app = require('@misterzik/espressojs');
+const config = require('@misterzik/espressojs/server');
+
+// Add custom routes
+app.use('/health', (req, res) => {
+  res.json({ status: 'ok', version: '1.0.0' });
+});
+
+// Manual server start
+const PORT = process.env.PORT || config.port;
+const server = app.listen(PORT, () => {
+  console.log(`Custom server on port ${PORT}`);
+});
+
+// Manual graceful shutdown
+process.on('SIGTERM', () => {
+  server.close(() => {
+    console.log('Server closed');
+    process.exit(0);
+  });
+});
+```
+
+**✅ Advantages:**
+- Maximum flexibility
+- Full control over everything
+- Custom error handling
+
+**❌ Disadvantages:**
+- Most complex
+- Must implement shutdown logic
+- More maintenance
+
+## Exported Functions (v3.3.6+)
+
+EspressoJS now exports these functions for programmatic usage:
+
+```javascript
+const {
+  startServer,        // Start server with all features
+  gracefulShutdown,   // Graceful shutdown handler
+  apiManager,         // API request manager
+  config,             // Configuration object
+  server              // HTTP server instance (after start)
+} = require('@misterzik/espressojs');
+```
+
+### startServer()
+
+Starts the Express server with all built-in features:
+- Port binding
+- Error handling
+- Graceful shutdown
+- Logging
+
+```javascript
+const { startServer } = require('@misterzik/espressojs');
+startServer();
+```
+
+### gracefulShutdown(signal)
+
+Manually trigger graceful shutdown:
+
+```javascript
+const { gracefulShutdown } = require('@misterzik/espressojs');
+
+// Custom shutdown trigger
+setTimeout(() => {
+  gracefulShutdown('CUSTOM_SHUTDOWN');
+}, 60000);
+```
+
+## Troubleshooting
+
+### Server Doesn't Start
+
+**Symptom:** No output, server not listening
+
+**Cause:** Using programmatic pattern without calling `startServer()` or `app.listen()`
+
+**Solution:**
+
+```javascript
+// Option 1: Use exported startServer
+const { startServer } = require('@misterzik/espressojs');
+startServer();
+
+// Option 2: Manual listen
+const app = require('@misterzik/espressojs');
+const config = require('@misterzik/espressojs/server');
+app.listen(config.port);
+```
+
+### Port Not Exposed
+
+**Symptom:** Server starts but port not accessible
+
+**Cause:** Server started but not bound to correct interface
+
+**Solution:**
+
+```javascript
+// Bind to all interfaces (0.0.0.0)
+const app = require('@misterzik/espressojs');
+app.listen(8080, '0.0.0.0', () => {
+  console.log('Server accessible on all interfaces');
+});
+```
+
+### Server Exits Immediately
+
+**Symptom:** Server starts then exits
+
+**Cause:** No event loop keeping process alive
+
+**Solution:**
+
+Use CLI method or ensure `app.listen()` is called:
+
+```bash
+# Use CLI (recommended)
+node cli run
+
+# Or ensure listen is called in code
+node index.js  # Must have app.listen() somewhere
+```
+
+### "Cannot find module" Error
+
+**Symptom:** Module not found when requiring EspressoJS
+
+**Cause:** Package not installed or wrong path
+
+**Solution:**
+
+```bash
+# Install package
+npm install @misterzik/espressojs
+
+# Verify installation
+npm list @misterzik/espressojs
+```
+
+## Best Practices
+
+### 1. Use CLI for Standard Deployments
+
+```bash
+npm start
+```
+
+### 2. Use startServer() for Programmatic Usage
+
+```javascript
+const { startServer } = require('@misterzik/espressojs');
+startServer();
+```
+
+### 3. Use Manual Listen for Maximum Control
+
+```javascript
+const app = require('@misterzik/espressojs');
+// Add custom middleware
+app.listen(3000);
+```
+
+### 4. Always Handle Errors
+
+```javascript
+const { startServer } = require('@misterzik/espressojs');
+
+try {
+  startServer();
+} catch (error) {
+  console.error('Failed to start:', error);
+  process.exit(1);
+}
+```
+
+### 5. Use Environment Variables
+
+```javascript
+const PORT = process.env.PORT || 8080;
+app.listen(PORT, () => {
+  console.log(`Server on port ${PORT}`);
+});
+```
+
+## Migration Guide
+
+### From Manual Listen to startServer()
+
+**Before (v3.3.5 and earlier):**
+
+```javascript
+const app = require('@misterzik/espressojs');
+const config = require('@misterzik/espressojs/server');
+
+app.listen(config.port, () => {
+  console.log(`Server running on ${config.port}`);
+});
+```
+
+**After (v3.3.6+):**
+
+```javascript
+const { startServer } = require('@misterzik/espressojs');
+
+startServer();
+// Logging and error handling included automatically
+```
+
+### Benefits of Migration
+
+- ✅ Built-in error handling
+- ✅ Graceful shutdown
+- ✅ Consistent logging
+- ✅ Less boilerplate code
+
+## Summary
+
+| Pattern | Auto-Start | Use Case | Complexity |
+|---------|-----------|----------|------------|
+| CLI | ✅ Yes | Production | Low |
+| Direct | ✅ Yes | Testing | Low |
+| Programmatic | ❌ No* | Integration | Medium |
+| Custom | ❌ No* | Advanced | High |
+
+*Use `startServer()` in v3.3.6+ for auto-start with full features
+
+## Support
+
+- **GitHub Issues**: https://github.com/misterzik/Espresso.js/issues
+- **Documentation**: https://github.com/misterzik/Espresso.js
+- **npm Package**: https://www.npmjs.com/package/@misterzik/espressojs
+
+---
+
+**Version:** 3.3.6+  
+**Last Updated:** 2024-12-25

package/index.js

@@ -203,6 +203,7 @@ process.on("uncaughtException", (error) => {
   gracefulShutdown("UNCAUGHT_EXCEPTION");
 });
 
+// Auto-start server if run directly (not required as module)
 if (require.main === module) {
   try {
     startServer();
@@ -213,6 +214,10 @@ if (require.main === module) {
   }
 }
 
+// Export app and utilities for programmatic usage
 module.exports = app;
 module.exports.apiManager = apiManager;
 module.exports.config = configData;
+module.exports.startServer = startServer;
+module.exports.gracefulShutdown = gracefulShutdown;
+module.exports.server = server;

package/package.json

@@ -1,15 +1,18 @@
 {
     "name": "@misterzik/espressojs",
-    "version": "3.3.4",
+    "version": "3.3.6",
     "description": "EspressoJS Introducing Espresso.JS, your ultimate Express configuration starting point and boilerplate. With its simplicity and lack of opinionation, EspressoJS offers plug-and-play configurations built on top of Express.",
     "main": "index.js",
     "scripts": {
         "test": "echo \"Error: no test specified\"",
         "start": "node cli run",
+        "start:watch": "nodemon cli run",
         "dev": "node cli env --instance=development --port=8080 && node cli run",
+        "dev:watch": "node cli env --instance=development --port=8080 && nodemon cli run",
         "global": "node cli env --instance=global --port=8081 && node cli run",
         "prod": "node cli env --instance=production --port=80 && node cli run",
         "show": "node cli show",
+        "validate": "node cli validate",
         "build-dev": "webpack --mode development",
         "build-prod": "webpack --mode production"
     },
@@ -60,7 +63,8 @@
         "@babel/core": "^7.23.7",
         "@babel/preset-env": "^7.23.7",
         "amd-define-factory-patcher-loader": "^1.0.0",
-        "babel-loader": "^9.1.3"
+        "babel-loader": "^9.1.3",
+        "nodemon": "^3.0.2"
     },
     "engines": {
         "node": ">= 0.10.0"

package/routes/index.js

@@ -38,8 +38,8 @@ module.exports = (app) => {
 
   if (configuration.api && configuration.api.enabled === true) {
     try {
-      const apiRoutes = require(path.join(rootDir, "routes", "api.js"));
-      app.use("/api", apiRoutes);
+      const apiRoutes = require(path.join(rootDir, "routes", "api", "index.js"));
+      app.use("/", apiRoutes.router);
       logger.info("API routes loaded successfully");
     } catch (error) {
       logger.warn(`API routes not found or failed to load: ${error.message}`);
@@ -56,6 +56,7 @@ module.exports = (app) => {
     }
   }
 
+  // Catch-all route must be last to avoid intercepting API routes
   app.get(
     "/*",
     asyncHandler(async (req, res) => {

package/server/utils/espresso-cli.js

@@ -76,7 +76,7 @@ function runCommand() {
       process.exit(code || 0);
     });
 
-    // Keep the CLI process alive
+    // Keep the CLI process alive by handling signals
     process.on('SIGINT', () => {
       console.log('\nShutting down server...');
       child.kill('SIGINT');
@@ -85,6 +85,10 @@ function runCommand() {
     process.on('SIGTERM', () => {
       child.kill('SIGTERM');
     });
+
+    // Prevent the process from exiting by keeping stdin open
+    // This ensures the CLI stays alive as long as the child process is running
+    process.stdin.resume();
   }
 }