@misterzik/espressojs 3.2.6 → 3.3.1

package/examples/mongodb-example.js

@@ -0,0 +1,149 @@
+/*
+ * EspressoJS - MongoDB Integration Example
+ * This file demonstrates how to use MongoDB with EspressoJS
+ */
+
+const express = require('express');
+const router = express.Router();
+const mongoose = require('mongoose');
+const { asyncHandler, AppError } = require('../server/middleware/errorHandler');
+
+// Example Schema
+const UserSchema = new mongoose.Schema({
+  name: {
+    type: String,
+    required: [true, 'Name is required'],
+    trim: true,
+    maxlength: [50, 'Name cannot exceed 50 characters']
+  },
+  email: {
+    type: String,
+    required: [true, 'Email is required'],
+    unique: true,
+    lowercase: true,
+    match: [/^\S+@\S+\.\S+$/, 'Please provide a valid email']
+  },
+  age: {
+    type: Number,
+    min: [0, 'Age must be positive']
+  },
+  createdAt: {
+    type: Date,
+    default: Date.now
+  },
+  updatedAt: {
+    type: Date,
+    default: Date.now
+  }
+});
+
+// Update timestamp on save
+UserSchema.pre('save', function(next) {
+  this.updatedAt = Date.now();
+  next();
+});
+
+const User = mongoose.model('User', UserSchema);
+
+// GET all users with pagination
+router.get('/users', asyncHandler(async (req, res) => {
+  const page = parseInt(req.query.page) || 1;
+  const limit = parseInt(req.query.limit) || 10;
+  const skip = (page - 1) * limit;
+
+  const users = await User.find()
+    .select('-__v')
+    .limit(limit)
+    .skip(skip)
+    .sort({ createdAt: -1 });
+
+  const total = await User.countDocuments();
+
+  res.status(200).json({
+    status: 'success',
+    results: users.length,
+    pagination: {
+      page,
+      limit,
+      total,
+      pages: Math.ceil(total / limit)
+    },
+    data: { users }
+  });
+}));
+
+// GET user by ID
+router.get('/users/:id', asyncHandler(async (req, res) => {
+  const user = await User.findById(req.params.id).select('-__v');
+
+  if (!user) {
+    throw new AppError('User not found', 404);
+  }
+
+  res.status(200).json({
+    status: 'success',
+    data: { user }
+  });
+}));
+
+// POST create new user
+router.post('/users', asyncHandler(async (req, res) => {
+  const user = await User.create(req.body);
+
+  res.status(201).json({
+    status: 'success',
+    data: { user }
+  });
+}));
+
+// PUT update user
+router.put('/users/:id', asyncHandler(async (req, res) => {
+  const user = await User.findByIdAndUpdate(
+    req.params.id,
+    req.body,
+    {
+      new: true,
+      runValidators: true
+    }
+  ).select('-__v');
+
+  if (!user) {
+    throw new AppError('User not found', 404);
+  }
+
+  res.status(200).json({
+    status: 'success',
+    data: { user }
+  });
+}));
+
+// DELETE user
+router.delete('/users/:id', asyncHandler(async (req, res) => {
+  const user = await User.findByIdAndDelete(req.params.id);
+
+  if (!user) {
+    throw new AppError('User not found', 404);
+  }
+
+  res.status(204).send();
+}));
+
+// GET users by query
+router.get('/users/search/:query', asyncHandler(async (req, res) => {
+  const { query } = req.params;
+
+  const users = await User.find({
+    $or: [
+      { name: { $regex: query, $options: 'i' } },
+      { email: { $regex: query, $options: 'i' } }
+    ]
+  }).select('-__v');
+
+  res.status(200).json({
+    status: 'success',
+    results: users.length,
+    data: { users }
+  });
+}));
+
+module.exports = router;

package/examples/multiple-apis.js

@@ -0,0 +1,149 @@
+/*
+ * EspressoJS - Multiple API Endpoints Example
+ * This example demonstrates how to use multiple API configurations
+ */
+
+const express = require('express');
+const router = express.Router();
+const { asyncHandler, AppError } = require('../server/middleware/errorHandler');
+const { apiManager } = require('../index');
+
+// Example 1: Using the API Manager directly
+router.get('/news', asyncHandler(async (req, res) => {
+  // Make a request to api2 endpoint
+  const newsData = await apiManager.request('api2', '');
+  
+  res.status(200).json({
+    status: 'success',
+    source: 'api2',
+    data: newsData
+  });
+}));
+
+// Example 2: Using multiple APIs in a single endpoint
+router.get('/combined-data', asyncHandler(async (req, res) => {
+  // Check which APIs are available
+  const availableAPIs = apiManager.getAllAPIs();
+  
+  // Make parallel requests to multiple APIs
+  const results = await Promise.allSettled([
+    apiManager.request('api', '/endpoint1'),
+    apiManager.request('api2', ''),
+    apiManager.request('api3', '/data')
+  ]);
+  
+  const data = {
+    api1: results[0].status === 'fulfilled' ? results[0].value : null,
+    api2: results[1].status === 'fulfilled' ? results[1].value : null,
+    api3: results[2].status === 'fulfilled' ? results[2].value : null,
+  };
+  
+  res.status(200).json({
+    status: 'success',
+    availableAPIs: Object.keys(availableAPIs),
+    data
+  });
+}));
+
+// Example 3: Using specific API with custom options
+router.get('/custom-request', asyncHandler(async (req, res) => {
+  const data = await apiManager.request('api3', '/custom-endpoint', {
+    method: 'POST',
+    data: { query: 'example' },
+    headers: {
+      'Custom-Header': 'value'
+    },
+    timeout: 5000,
+    retries: 2
+  });
+  
+  res.status(200).json({
+    status: 'success',
+    data
+  });
+}));
+
+// Example 4: Creating a custom Axios instance for an API
+router.get('/axios-instance', asyncHandler(async (req, res) => {
+  // Create a custom axios instance for api2
+  const api2Client = apiManager.createAxiosInstance('api2');
+  
+  // Use it like regular axios
+  const response = await api2Client.get('/specific-endpoint');
+  
+  res.status(200).json({
+    status: 'success',
+    data: response.data
+  });
+}));
+
+// Example 5: Conditional API usage based on availability
+router.get('/smart-fetch', asyncHandler(async (req, res) => {
+  let data;
+  
+  // Try primary API first, fallback to secondary
+  if (apiManager.hasAPI('api')) {
+    try {
+      data = await apiManager.request('api', '/data');
+    } catch (error) {
+      // Fallback to api3 if api fails
+      if (apiManager.hasAPI('api3')) {
+        data = await apiManager.request('api3', '/data');
+      } else {
+        throw new AppError('No API endpoints available', 503);
+      }
+    }
+  } else if (apiManager.hasAPI('api3')) {
+    data = await apiManager.request('api3', '/data');
+  } else {
+    throw new AppError('No API endpoints configured', 503);
+  }
+  
+  res.status(200).json({
+    status: 'success',
+    data
+  });
+}));
+
+// Example 6: List all configured APIs
+router.get('/api-info', (req, res) => {
+  const apis = apiManager.getAllAPIs();
+  
+  const apiInfo = Object.entries(apis).map(([name, config]) => ({
+    name,
+    baseURL: config.baseURL,
+    method: config.method,
+    timeout: config.timeout,
+    retries: config.retries
+  }));
+  
+  res.status(200).json({
+    status: 'success',
+    count: apiInfo.length,
+    apis: apiInfo
+  });
+});
+
+// Example 7: Proxy endpoint for any API
+router.get('/proxy/:apiName/*', asyncHandler(async (req, res) => {
+  const { apiName } = req.params;
+  const endpoint = req.params[0];
+  
+  if (!apiManager.hasAPI(apiName)) {
+    throw new AppError(`API '${apiName}' not found`, 404);
+  }
+  
+  const data = await apiManager.request(apiName, `/${endpoint}`, {
+    method: req.method,
+    params: req.query
+  });
+  
+  res.status(200).json({
+    status: 'success',
+    api: apiName,
+    endpoint,
+    data
+  });
+}));
+
+module.exports = router;

package/index.js

@@ -17,7 +17,11 @@ const {
   readConfigFile,
   setCustomCacheControl,
 } = require("./server/utils/config.utils");
+const { validateEnvVariables } = require("./server/utils/configValidator");
+const logger = require("./server/utils/logger");
+const APIManager = require("./server/utils/apiManager");
 const configData = readConfigFile();
+const apiManager = new APIManager(configData);
 
 const Path = require("path");
 const Cors = require("cors");
@@ -25,17 +29,35 @@ const Compression = require("compression");
 const Favicon = require("serve-favicon");
 const Static = require("serve-static");
 const mongoose = require("mongoose");
+const morgan = require("morgan");
 const Routes = require("./routes/index");
 
+const {
+  helmetConfig,
+  rateLimiter,
+} = require("./server/middleware/security");
+const {
+  errorHandler,
+  notFoundHandler,
+} = require("./server/middleware/errorHandler");
+const {
+  healthCheck,
+  readinessCheck,
+  livenessCheck,
+} = require("./server/middleware/healthCheck");
+
 const Port = configData.port || cfg.port;
-const mongoConfig = configData.mongo;
+const mongoConfig = configData.mongoDB;
 const rootDir = process.cwd();
+const publicDir = configData.publicDirectory || "/public";
+
+validateEnvVariables();
 
-if (configData.mongo_isEnabled) {
+if (configData.mongoDB.enabled) {
   const {
-    uri: mongoUri = configData.mongo.uri || "",
-    port: mongoPort = configData.mongo.port || "",
-    db: mongoDb = configData.mongo.db || "",
+    uri: mongoUri = configData.mongoDB.uri || "",
+    port: mongoPort = configData.mongoDB.port || "",
+    db: mongoDb = configData.mongoDB.instance || "",
   } = mongoConfig;
   const hasPort = mongoPort ? `:${mongoPort}/` : "/";
   const url = `mongodb+srv://${
@@ -55,26 +77,103 @@ if (configData.mongo_isEnabled) {
       useNewUrlParser: true,
       promiseLibrary: require("bluebird"),
     })
-    .then(() => console.log(":: DB Connection successful ::"))
-    .catch((err) => console.error(err));
+    .then(() => logger.info(":: DB Connection successful ::"))
+    .catch((err) => logger.error(`DB Connection error: ${err.message}`));
 }
 
+app.use(helmetConfig());
 app.use(Compression());
 app.use(Cors());
-app.use(express.urlencoded({ extended: false }));
-app.use(express.json());
-app.use(Favicon(Path.join(rootDir, "public", "favicon.ico")));
+app.use(express.urlencoded({ extended: false, limit: "10mb" }));
+app.use(express.json({ limit: "10mb" }));
+
+const morganFormat = process.env.NODE_ENV === "production" ? "combined" : "dev";
+app.use(
+  morgan(morganFormat, {
+    stream: {
+      write: (message) => logger.http(message.trim()),
+    },
+  })
+);
+
+app.use(rateLimiter);
+
+app.get("/health", healthCheck);
+app.get("/ready", readinessCheck);
+app.get("/alive", livenessCheck);
+
+app.use(Favicon(Path.join(rootDir, publicDir, "favicon.ico")));
 app.use(
-  Static(Path.join(rootDir, "public"), {
+  Static(Path.join(rootDir, publicDir), {
     maxAge: "1d",
     setHeaders: setCustomCacheControl,
     etag: true,
     extensions: "error.html",
   })
 );
+
 Routes(app);
-app.listen(Port, () => {
-  console.log(`Server is running on port ${Port}`);
+
+app.use(notFoundHandler);
+app.use(errorHandler);
+
+let server;
+
+const startServer = () => {
+  server = app.listen(Port, () => {
+    logger.info(`
+╔═══════════════════════════════════════════════════════╗
+║                   ESPRESSO.JS                         ║
+║              Express Boilerplate Server               ║
+╠═══════════════════════════════════════════════════════╣
+║  Environment: ${configData.instance.padEnd(39)} ║
+║  Port:        ${Port.toString().padEnd(39)} ║
+║  URL:         http://localhost:${Port.toString().padEnd(27)} ║
+║  MongoDB:     ${(configData.mongoDB.enabled ? "Enabled" : "Disabled").padEnd(39)} ║
+║  API:         ${(configData.api.enabled ? "Enabled" : "Disabled").padEnd(39)} ║
+╚═══════════════════════════════════════════════════════╝
+    `);
+  });
+};
+
+const gracefulShutdown = (signal) => {
+  logger.info(`${signal} received. Starting graceful shutdown...`);
+  
+  server.close(() => {
+    logger.info("HTTP server closed");
+    
+    if (mongoose.connection.readyState === 1) {
+      mongoose.connection.close(false, () => {
+        logger.info("MongoDB connection closed");
+        process.exit(0);
+      });
+    } else {
+      process.exit(0);
+    }
+  });
+
+  setTimeout(() => {
+    logger.error("Forced shutdown after timeout");
+    process.exit(1);
+  }, 10000);
+};
+
+process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
+process.on("SIGINT", () => gracefulShutdown("SIGINT"));
+
+process.on("unhandledRejection", (reason, promise) => {
+  logger.error(`Unhandled Rejection at: ${promise}, reason: ${reason}`);
+});
+
+process.on("uncaughtException", (error) => {
+  logger.error(`Uncaught Exception: ${error.message}`);
+  gracefulShutdown("UNCAUGHT_EXCEPTION");
 });
 
+if (require.main === module) {
+  startServer();
+}
+
 module.exports = app;
+module.exports.apiManager = apiManager;
+module.exports.config = configData;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@misterzik/espressojs",
-    "version": "3.2.6",
+    "version": "3.3.1",
     "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": {
@@ -36,17 +36,23 @@
     },
     "homepage": "https://github.com/misterzik/Espresso.js#readme",
     "dependencies": {
-        "axios": "^1.4.0",
+        "axios": "^1.6.0",
         "bluebird": "^3.7.2",
+        "compression": "^1.7.4",
+        "cors": "^2.8.5",
         "cross-env": "^7.0.3",
-        "express": "^4.18.2",
-        "mongoose": "^7.3.1",
         "dotenv": "^16.3.1",
-        "cors": "^2.8.5",
+        "express": "^4.18.2",
+        "express-rate-limit": "^7.1.5",
+        "express-validator": "^7.0.1",
         "finalhandler": "^1.2.0",
-        "compression": "^1.7.4",
-        "serve-static": "^1.15.0",
+        "helmet": "^7.1.0",
+        "joi": "^17.11.0",
+        "mongoose": "^8.0.3",
+        "morgan": "^1.10.0",
         "serve-favicon": "^2.5.0",
+        "serve-static": "^1.15.0",
+        "winston": "^3.11.0",
         "yargs": "^17.7.2"
     },
     "devDependencies": {

package/routes/index.js

@@ -10,27 +10,64 @@
  */
 
 const path = require("path");
+const fs = require("fs");
 const configuration = require("../server");
+const logger = require("../server/utils/logger");
+const { asyncHandler } = require("../server/middleware/errorHandler");
 const rootDir = process.cwd();
-const api = require(path.join(rootDir, "routes", "api.js"));
-const db = require(path.join(rootDir, "routes", "db.js"));
 
 module.exports = (app) => {
-  app.get("/", function (req, res) {
-    const filePath = path.join(rootDir, "public", "index.html");
-    res.sendFile(filePath);
-  });
+  app.get(
+    "/",
+    asyncHandler(async (req, res) => {
+      const filePath = path.join(rootDir, "public", "index.html");
+      
+      if (!fs.existsSync(filePath)) {
+        logger.warn("index.html not found, sending default response");
+        return res.status(200).json({
+          message: "Welcome to EspressoJS",
+          version: "3.2.6",
+          documentation: "https://github.com/misterzik/Espresso.js",
+        });
+      }
+      
+      res.sendFile(filePath);
+    })
+  );
+
   if (configuration.api_isEnabled === true) {
-    app.use("/api", api);
+    try {
+      const apiRoutes = require(path.join(rootDir, "routes", "api.js"));
+      app.use("/api", apiRoutes);
+      logger.info("API routes loaded successfully");
+    } catch (error) {
+      logger.warn(`API routes not found or failed to load: ${error.message}`);
+    }
   }
+
   if (configuration.mongo_isEnabled === true) {
-    app.use("/api", db);
+    try {
+      const dbRoutes = require(path.join(rootDir, "routes", "db.js"));
+      app.use("/api/db", dbRoutes);
+      logger.info("Database routes loaded successfully");
+    } catch (error) {
+      logger.warn(`Database routes not found or failed to load: ${error.message}`);
+    }
   }
-  app.get("/*", function (req, res) {
-    const filePath = path.join(rootDir, "public", "index.html");
-    res.sendFile(filePath);
-  });
-  app.use(function (req, res, next) {
-    res.status(404).send("404 - Sorry can't find that!");
-  });
+
+  app.get(
+    "/*",
+    asyncHandler(async (req, res) => {
+      const filePath = path.join(rootDir, "public", "index.html");
+      
+      if (!fs.existsSync(filePath)) {
+        return res.status(404).json({
+          status: "error",
+          message: "Page not found",
+        });
+      }
+      
+      res.sendFile(filePath);
+    })
+  );
 };

package/server/middleware/errorHandler.js

@@ -0,0 +1,73 @@
+/*
+ * _|      _|  _|      _|  _|_|_|
+ * _|      _|  _|_|  _|_|  _|    _|
+ * _|      _|  _|  _|  _|  _|    _|
+ *   _|  _|    _|      _|  _|    _|
+ *     _|      _|      _|  _|_|_|
+ * EspressoJS - Error Handler Middleware
+ */
+
+const logger = require("../utils/logger");
+
+class AppError extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.status = `${statusCode}`.startsWith("4") ? "fail" : "error";
+    this.isOperational = true;
+
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+const errorHandler = (err, req, res, next) => {
+  err.statusCode = err.statusCode || 500;
+  err.status = err.status || "error";
+
+  logger.error(
+    `${err.statusCode} - ${err.message} - ${req.originalUrl} - ${req.method} - ${req.ip}`
+  );
+
+  if (process.env.NODE_ENV === "development") {
+    res.status(err.statusCode).json({
+      status: err.status,
+      error: err,
+      message: err.message,
+      stack: err.stack,
+    });
+  } else {
+    if (err.isOperational) {
+      res.status(err.statusCode).json({
+        status: err.status,
+        message: err.message,
+      });
+    } else {
+      logger.error("ERROR 💥", err);
+      res.status(500).json({
+        status: "error",
+        message: "Something went wrong!",
+      });
+    }
+  }
+};
+
+const notFoundHandler = (req, res, next) => {
+  const err = new AppError(
+    `Cannot find ${req.originalUrl} on this server!`,
+    404
+  );
+  next(err);
+};
+
+const asyncHandler = (fn) => {
+  return (req, res, next) => {
+    Promise.resolve(fn(req, res, next)).catch(next);
+  };
+};
+
+module.exports = {
+  AppError,
+  errorHandler,
+  notFoundHandler,
+  asyncHandler,
+};