@misterzik/espressojs 3.2.6 → 3.3.1

package/server/middleware/healthCheck.js

@@ -0,0 +1,71 @@
+/*
+ * _|      _|  _|      _|  _|_|_|
+ * _|      _|  _|_|  _|_|  _|    _|
+ * _|      _|  _|  _|  _|  _|    _|
+ *   _|  _|    _|      _|  _|    _|
+ *     _|      _|      _|  _|_|_|
+ * EspressoJS - Health Check Middleware
+ */
+
+const mongoose = require("mongoose");
+const os = require("os");
+
+const healthCheck = (req, res) => {
+  const healthData = {
+    status: "OK",
+    timestamp: new Date().toISOString(),
+    uptime: process.uptime(),
+    environment: process.env.NODE_ENV || "development",
+    memory: {
+      total: os.totalmem(),
+      free: os.freemem(),
+      usage: process.memoryUsage(),
+    },
+    cpu: {
+      cores: os.cpus().length,
+      loadAverage: os.loadavg(),
+    },
+  };
+
+  if (mongoose.connection.readyState === 1) {
+    healthData.database = {
+      status: "connected",
+      name: mongoose.connection.name,
+    };
+  } else if (mongoose.connection.readyState === 0) {
+    healthData.database = {
+      status: "disconnected",
+    };
+  }
+
+  res.status(200).json(healthData);
+};
+
+const readinessCheck = (req, res) => {
+  const isReady = mongoose.connection.readyState === 1 || mongoose.connection.readyState === 0;
+
+  if (isReady) {
+    res.status(200).json({
+      status: "ready",
+      timestamp: new Date().toISOString(),
+    });
+  } else {
+    res.status(503).json({
+      status: "not ready",
+      timestamp: new Date().toISOString(),
+    });
+  }
+};
+
+const livenessCheck = (req, res) => {
+  res.status(200).json({
+    status: "alive",
+    timestamp: new Date().toISOString(),
+  });
+};
+
+module.exports = {
+  healthCheck,
+  readinessCheck,
+  livenessCheck,
+};

package/server/middleware/security.js

@@ -0,0 +1,60 @@
+/*
+ * _|      _|  _|      _|  _|_|_|
+ * _|      _|  _|_|  _|_|  _|    _|
+ * _|      _|  _|  _|  _|  _|    _|
+ *   _|  _|    _|      _|  _|    _|
+ *     _|      _|      _|  _|_|_|
+ * EspressoJS - Security Middleware
+ */
+
+const helmet = require("helmet");
+const rateLimit = require("express-rate-limit");
+
+const helmetConfig = () => {
+  return helmet({
+    contentSecurityPolicy: {
+      directives: {
+        defaultSrc: ["'self'"],
+        styleSrc: ["'self'", "'unsafe-inline'"],
+        scriptSrc: ["'self'", "'unsafe-inline'"],
+        imgSrc: ["'self'", "data:", "https:"],
+      },
+    },
+    crossOriginEmbedderPolicy: false,
+    crossOriginResourcePolicy: { policy: "cross-origin" },
+  });
+};
+
+const rateLimiter = rateLimit({
+  windowMs: 15 * 60 * 1000,
+  max: 100,
+  message: "Too many requests from this IP, please try again later.",
+  standardHeaders: true,
+  legacyHeaders: false,
+});
+
+const strictRateLimiter = rateLimit({
+  windowMs: 15 * 60 * 1000,
+  max: 10,
+  message: "Too many requests from this IP, please try again later.",
+  standardHeaders: true,
+  legacyHeaders: false,
+});
+
+const apiRateLimiter = rateLimit({
+  windowMs: 15 * 60 * 1000,
+  max: 200,
+  message: {
+    status: "error",
+    message: "Too many API requests from this IP, please try again later.",
+  },
+  standardHeaders: true,
+  legacyHeaders: false,
+});
+
+module.exports = {
+  helmetConfig,
+  rateLimiter,
+  strictRateLimiter,
+  apiRateLimiter,
+};

package/server/utils/apiManager.js

@@ -0,0 +1,110 @@
+/*
+ * _|      _|  _|      _|  _|_|_|
+ * _|      _|  _|_|  _|_|  _|    _|
+ * _|      _|  _|  _|  _|  _|    _|
+ *   _|  _|    _|      _|  _|    _|
+ *     _|      _|      _|  _|_|_|
+ * EspressoJS - API Manager Utility
+ */
+
+const axios = require("axios");
+const logger = require("./logger");
+
+class APIManager {
+  constructor(config) {
+    this.apis = {};
+    this.loadAPIs(config);
+  }
+
+  loadAPIs(config) {
+    const apiKeys = Object.keys(config).filter(key => key.match(/^api\d*$/));
+    
+    apiKeys.forEach(key => {
+      const apiConfig = config[key];
+      
+      if (apiConfig && (apiConfig.enabled !== false)) {
+        this.apis[key] = {
+          name: key,
+          baseURL: apiConfig.uri || apiConfig.url || "",
+          method: (apiConfig.method || "GET").toUpperCase(),
+          headers: apiConfig.headers || { "Content-Type": "application/json" },
+          timeout: apiConfig.timeout || 30000,
+          retries: apiConfig.retries || 0,
+        };
+        
+        logger.info(`API endpoint '${key}' loaded: ${this.apis[key].baseURL}`);
+      }
+    });
+
+    logger.info(`Total API endpoints loaded: ${Object.keys(this.apis).length}`);
+  }
+
+  getAPI(name = "api") {
+    return this.apis[name];
+  }
+
+  getAllAPIs() {
+    return this.apis;
+  }
+
+  hasAPI(name) {
+    return !!this.apis[name];
+  }
+
+  async request(apiName, endpoint = "", options = {}) {
+    const api = this.getAPI(apiName);
+    
+    if (!api) {
+      throw new Error(`API '${apiName}' not found in configuration`);
+    }
+
+    const url = endpoint ? `${api.baseURL}${endpoint}` : api.baseURL;
+    const config = {
+      method: options.method || api.method,
+      url,
+      headers: { ...api.headers, ...options.headers },
+      timeout: options.timeout || api.timeout,
+      ...options,
+    };
+
+    let lastError;
+    const maxRetries = options.retries !== undefined ? options.retries : api.retries;
+
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        logger.debug(`API request to ${apiName}: ${config.method} ${url} (attempt ${attempt + 1}/${maxRetries + 1})`);
+        const response = await axios(config);
+        
+        logger.info(`API ${apiName} request successful: ${response.status}`);
+        return response.data;
+      } catch (error) {
+        lastError = error;
+        logger.warn(`API ${apiName} request failed (attempt ${attempt + 1}/${maxRetries + 1}): ${error.message}`);
+        
+        if (attempt < maxRetries) {
+          const delay = Math.min(1000 * Math.pow(2, attempt), 10000);
+          await new Promise(resolve => setTimeout(resolve, delay));
+        }
+      }
+    }
+
+    logger.error(`API ${apiName} request failed after ${maxRetries + 1} attempts`);
+    throw lastError;
+  }
+
+  createAxiosInstance(apiName) {
+    const api = this.getAPI(apiName);
+    
+    if (!api) {
+      throw new Error(`API '${apiName}' not found in configuration`);
+    }
+
+    return axios.create({
+      baseURL: api.baseURL,
+      timeout: api.timeout,
+      headers: api.headers,
+    });
+  }
+}
+
+module.exports = APIManager;

package/server/utils/config.utils.js

@@ -1,15 +1,65 @@
 const Static = require("serve-static");
 const fs = require("fs");
+const path = require("path");
+const { validateConfig } = require("./configValidator");
+const logger = require("./logger");
 
 function readConfigFile() {
-  const cfgBuffer = fs.readFileSync("./config.json");
-  const cfgBuJSON = cfgBuffer.toString();
-  return JSON.parse(cfgBuJSON);
+  try {
+    const configPath = path.join(process.cwd(), "config.json");
+    
+    if (!fs.existsSync(configPath)) {
+      logger.warn("config.json not found, using default configuration");
+      return getDefaultConfig();
+    }
+
+    const cfgBuffer = fs.readFileSync(configPath);
+    const cfgBuJSON = cfgBuffer.toString();
+    const config = JSON.parse(cfgBuJSON);
+    
+    return validateConfig(config);
+  } catch (error) {
+    logger.error(`Error reading config file: ${error.message}`);
+    return getDefaultConfig();
+  }
 }
 
 function writeConfigFile(cfg) {
-  const instUpdate = JSON.stringify(cfg);
-  fs.writeFileSync("config.json", instUpdate);
+  try {
+    const validatedConfig = validateConfig(cfg);
+    const instUpdate = JSON.stringify(validatedConfig, null, 2);
+    fs.writeFileSync("config.json", instUpdate);
+    logger.info("Configuration file updated successfully");
+  } catch (error) {
+    logger.error(`Error writing config file: ${error.message}`);
+    throw error;
+  }
+}
+
+function getDefaultConfig() {
+  return {
+    instance: "development",
+    port: 8080,
+    hostname: "",
+    publicDirectory: "/public",
+    mongoDB: {
+      enabled: false,
+      port: null,
+      uri: "",
+      instance: "database",
+    },
+    api: {
+      enabled: false,
+      uri: "",
+      url: "",
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      timeout: 30000,
+      retries: 0,
+    },
+  };
 }
 
 const vmdLogo = `
@@ -30,6 +80,7 @@ const setCustomCacheControl = (res, path) => {
 module.exports = {
   readConfigFile,
   writeConfigFile,
+  getDefaultConfig,
   vmdLogo,
   setCustomCacheControl,
 };

package/server/utils/configValidator.js

@@ -0,0 +1,90 @@
+/*
+ * _|      _|  _|      _|  _|_|_|
+ * _|      _|  _|_|  _|_|  _|    _|
+ * _|      _|  _|  _|  _|  _|    _|
+ *   _|  _|    _|      _|  _|    _|
+ *     _|      _|      _|  _|_|_|
+ * EspressoJS - Configuration Validator
+ */
+
+const Joi = require("joi");
+const logger = require("./logger");
+
+const apiSchema = Joi.object({
+  enabled: Joi.boolean().default(true),
+  uri: Joi.string().uri().allow("").default(""),
+  url: Joi.string().allow("").default(""),
+  method: Joi.string()
+    .valid("GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS")
+    .default("GET"),
+  headers: Joi.object().default({ "Content-Type": "application/json" }),
+  timeout: Joi.number().integer().min(0).default(30000),
+  retries: Joi.number().integer().min(0).max(5).default(0),
+});
+
+const configSchema = Joi.object({
+  instance: Joi.string()
+    .valid("development", "production", "global")
+    .default("development"),
+  port: Joi.number().port().default(8080),
+  hostname: Joi.string().hostname().allow("").default(""),
+  publicDirectory: Joi.string().default("/public"),
+  mongoDB: Joi.object({
+    enabled: Joi.boolean().default(false),
+    port: Joi.number().port().allow(null).default(null),
+    uri: Joi.string().allow("").default(""),
+    instance: Joi.string().default("database"),
+  }).default(),
+  api: apiSchema.default(),
+}).unknown(true);
+
+const validateConfig = (config) => {
+  const { error, value } = configSchema.validate(config, {
+    abortEarly: false,
+    allowUnknown: true,
+  });
+
+  if (error) {
+    const errorMessages = error.details.map((detail) => detail.message);
+    logger.error(`Configuration validation failed: ${errorMessages.join(", ")}`);
+    throw new Error(`Invalid configuration: ${errorMessages.join(", ")}`);
+  }
+
+  const validatedConfig = { ...value };
+  const apiKeys = Object.keys(config).filter(key => key.match(/^api\d*$/));
+  
+  apiKeys.forEach(key => {
+    const { error: apiError, value: apiValue } = apiSchema.validate(config[key], {
+      abortEarly: false,
+    });
+    
+    if (apiError) {
+      const errorMessages = apiError.details.map((detail) => detail.message);
+      logger.warn(`API configuration '${key}' validation warning: ${errorMessages.join(", ")}`);
+    }
+    
+    validatedConfig[key] = apiValue || config[key];
+  });
+
+  logger.info(`Configuration validated successfully with ${apiKeys.length} API endpoint(s)`);
+  return validatedConfig;
+};
+
+const validateEnvVariables = () => {
+  const requiredEnvVars = [];
+  const missingVars = requiredEnvVars.filter((varName) => !process.env[varName]);
+
+  if (missingVars.length > 0) {
+    logger.warn(
+      `Missing optional environment variables: ${missingVars.join(", ")}`
+    );
+  }
+
+  return true;
+};
+
+module.exports = {
+  validateConfig,
+  validateEnvVariables,
+  configSchema,
+};

package/server/utils/espresso-cli.js

@@ -7,20 +7,28 @@
  * EspressoJS - CLI
  */
 
-const { exec } = require("child_process");
-const { string, number } = require("yargs");
+const { exec, spawn } = require("child_process");
+const { string, number, boolean } = require("yargs");
 const yargs = require("yargs");
-const { readConfigFile, writeConfigFile, vmdLogo } = require("./config.utils");
+const fs = require("fs");
+const path = require("path");
+const { readConfigFile, writeConfigFile, vmdLogo, getDefaultConfig } = require("./config.utils");
 
 const cfgB = readConfigFile();
+
 function showCommand() {
-  console.log(cfgB);
+  console.log("\n╔═══════════════════════════════════════════════════════╗");
+  console.log("║              ESPRESSO.JS CONFIGURATION                ║");
+  console.log("╚═══════════════════════════════════════════════════════╝\n");
+  console.log(JSON.stringify(cfgB, null, 2));
+  console.log("\n");
 }
+
 function runCommand() {
   if (cfgB !== undefined) {
     const cmd_ct = vmdLogo;
-    console.warn(`${cmd_ct}`);
-    console.warn(
+    console.log(`${cmd_ct}`);
+    console.log(
       `Espresso CLI
 --------------
 Warming Up Configs..
@@ -30,63 +38,141 @@ Instance Config:
 Configuration: ${cfgB.instance}
 Endpoint: http://localhost:${cfgB.port}
 JSON:`,
-      cfgB,
-      `\n\nTo stop process press CTRL+C`
+      JSON.stringify(cfgB, null, 2),
+      `\n\nTo stop process press CTRL+C\n`
     );
-    exec(
-      `node ./node_modules/cross-env/src/bin/cross-env NODE_ENV=${cfgB.instance} PORT=${cfgB.port} node index.js`,
-      (error, stdout, stderr) => {
-        if (error) {
-          console.log(`error: ${error.message}`);
-          return;
-        }
-        if (stderr) {
-          console.log(`stderr: ${stderr}`);
-          return;
-        }
-        console.log(`stdout: ${stdout}`);
-      }
+    
+    const child = spawn(
+      "node",
+      ["./node_modules/cross-env/src/bin/cross-env", `NODE_ENV=${cfgB.instance}`, `PORT=${cfgB.port}`, "node", "index.js"],
+      { stdio: "inherit", shell: true }
     );
+
+    child.on("error", (error) => {
+      console.error(`Error: ${error.message}`);
+    });
+
+    child.on("exit", (code) => {
+      if (code !== 0) {
+        console.error(`Process exited with code ${code}`);
+      }
+    });
   }
 }
+
 function envCommand(argv) {
-  if (argv.instance !== undefined) {
-    cfgB.instance = argv.instance;
+  try {
+    if (argv.instance !== undefined) {
+      cfgB.instance = argv.instance;
+      console.log(`✓ Instance set to: ${argv.instance}`);
+    }
+    if (argv.port !== undefined && cfgB.port !== argv.port) {
+      cfgB.port = argv.port;
+      console.log(`✓ Port set to: ${argv.port}`);
+    }
+    writeConfigFile(cfgB);
+    console.log("✓ Configuration saved successfully");
+  } catch (error) {
+    console.error(`✗ Error saving configuration: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+function initCommand(argv) {
+  const configPath = path.join(process.cwd(), "config.json");
+  
+  if (fs.existsSync(configPath) && !argv.force) {
+    console.error("✗ config.json already exists. Use --force to overwrite.");
+    process.exit(1);
   }
-  if (cfgB.port !== argv.port) {
-    cfgB.port = argv.port;
-    console.warn("New config saved...");
-  } else {
-    console.warn("Config already saved...");
+
+  const defaultConfig = getDefaultConfig();
+  writeConfigFile(defaultConfig);
+  console.log("✓ config.json created successfully");
+  console.log("\nDefault configuration:");
+  console.log(JSON.stringify(defaultConfig, null, 2));
+}
+
+function validateCommand() {
+  try {
+    const configPath = path.join(process.cwd(), "config.json");
+    
+    if (!fs.existsSync(configPath)) {
+      console.error("✗ config.json not found");
+      process.exit(1);
+    }
+
+    readConfigFile();
+    console.log("✓ Configuration is valid");
+  } catch (error) {
+    console.error(`✗ Configuration validation failed: ${error.message}`);
+    process.exit(1);
   }
-  writeConfigFile(cfgB);
 }
 
-yargs.command({
-  command: "show",
-  describe: "Show pre-compiled Instance",
-  handler: showCommand,
-});
-yargs.command({
-  command: "run",
-  describe: "Run pre-compiled Instance",
-  handler: runCommand,
-});
-yargs.command({
-  command: "env",
-  describe: "Environment Configurations",
-  builder: {
-    instance: {
-      describe: "Instance to run global, dev, prod --instance=dev",
-      demandOption: false,
-      type: string,
+function versionCommand() {
+  const packagePath = path.join(__dirname, "../../package.json");
+  const pkg = JSON.parse(fs.readFileSync(packagePath, "utf8"));
+  console.log(`\nEspressoJS v${pkg.version}`);
+  console.log(`Node ${process.version}`);
+  console.log(`Platform: ${process.platform}\n`);
+}
+
+yargs
+  .scriptName("espresso")
+  .usage("$0 <command> [options]")
+  .command({
+    command: "show",
+    describe: "Show current configuration",
+    handler: showCommand,
+  })
+  .command({
+    command: "run",
+    describe: "Run the Express server with current configuration",
+    handler: runCommand,
+  })
+  .command({
+    command: "env",
+    describe: "Update environment configuration",
+    builder: {
+      instance: {
+        describe: "Instance to run: development, production, or global",
+        demandOption: false,
+        type: string,
+        choices: ["development", "production", "global"],
+      },
+      port: {
+        describe: "Port number for the server",
+        demandOption: false,
+        type: number,
+      },
     },
-    port: {
-      describe: "Instance Port --port=8080",
-      demandOption: true,
-      type: number,
+    handler: envCommand,
+  })
+  .command({
+    command: "init",
+    describe: "Initialize a new config.json file",
+    builder: {
+      force: {
+        describe: "Overwrite existing config.json",
+        type: boolean,
+        default: false,
+      },
     },
-  },
-  handler: envCommand,
-});
-yargs.parse();
+    handler: initCommand,
+  })
+  .command({
+    command: "validate",
+    describe: "Validate the current configuration",
+    handler: validateCommand,
+  })
+  .command({
+    command: "version",
+    describe: "Show version information",
+    handler: versionCommand,
+  })
+  .demandCommand(1, "You need to specify a command")
+  .help()
+  .alias("h", "help")
+  .alias("v", "version")
+  .parse();