@feardread/fear 1.2.1 → 2.0.0

package/FEAR.js

@@ -1,10 +1,13 @@
 const path = require("path");
 const fs = require("fs");
 const express = require("express");
+const session = require('express-session');
 const compression = require("compression");
 const cookieParser = require("cookie-parser");
 const fileUpload = require("express-fileupload");
 const cors = require("cors");
+const MongoStore = require('connect-mongo');
+const passport = require('passport');
 
 module.exports = FEAR = (() => {
   // Private constants
@@ -14,7 +17,7 @@ module.exports = FEAR = (() => {
   const AGENT_ROUTE_PATH = '/fear/api/agent';
 
   // Constructor function
-  const FEAR = function() {
+  const FEAR = function (config) {
     this.app = express();
     this.Router = express.Router;
     this.server = null;
@@ -29,100 +32,67 @@ module.exports = FEAR = (() => {
     this.logo = null;
     this.origins = [];
     this.corsConfig = null;
+    this.stripe = null;
+    this.paypal = null;
+    this.passport = null;
+    this.mailer = null;
+
 
-    // Initialize
     this.setupEnvironment();
     this.setupDependencies();
+    if (this.env.ADD_PAYMENTS) this.setupProcessors();
+    this.setupMailer();
     this.setupMiddleware();
     this.corsConfig = this.getCorsConfig();
     this.setupRoutes();
   };
 
-  // Consolidated prototype
+
   FEAR.prototype = {
     constructor: FEAR,
-
-    /**
-     * Get AI Agent service instance
-     */
-    getAiAgent() {
-      return this.agentService;
+    getStripe() {
+      return this.stripe;
+    },
+    getPassport() {
+      return this.passport;
     },
-
-    /**
-     * Clear global FearRouter
-     */
     clearGlobal() {
       delete global.FearRouter;
       return this;
     },
-
-    /**
-     * Get Express app instance
-     */
     getApp() {
       return this.app;
     },
-
-    /**
-     * Get logger instance
-     */
     getLogger() {
       return this.logger;
     },
-
-    /**
-     * Get database instance
-     */
     getDatabase() {
       return this.db;
     },
-
-    /**
-     * Get environment configuration
-     */
     getEnvironment() {
       return this.env;
     },
-
-    /**
-     * Get cloud service instance
-     */
     getCloud() {
       return this.cloud;
     },
-
-    /**
-     * Get Express Router
-     */
     getRouter() {
       return this.Router;
     },
-
-    /**
-     * Get validator instance
-     */
     getValidator() {
       return this.validator;
     },
-
-    /**
-     * Get handler instance
-     */
     getHandler() {
       return this.handler;
     },
-
-    /**
-     * Get CORS configuration
-     */
+    getPaypal() {
+      return this.paypal;
+    },
+    getMailer() {
+      return this.mailer;
+    },
     getCorsConfigValue() {
       return this.corsConfig;
     },
-
-    /**
-     * Setup environment variables from .env file
-     */
     setupEnvironment() {
       const envResult = require("dotenv").config({ path: ".env" });
 
@@ -138,6 +108,7 @@ module.exports = FEAR = (() => {
      */
     setupDependencies() {
       this.logger = require("./libs/logger");
+      this.passport = require('./libs/passport');
       this.morgan = require("./libs/logger/morgan");
       this.cloud = require("./libs/cloud");
       this.db = require("./libs/db");
@@ -147,26 +118,66 @@ module.exports = FEAR = (() => {
       this.origins = this.getAllowedOrigins();
     },
 
+    setupProcessors() {
+      const StripeHandler = require("./libs/stripe");
+      const PayPal = require('./libs/paypal');
+
+      if ( !this.env.PAYPAL_CLIENT_ID|| !this.env.STRIPE_API_KEY ) {
+        this.logger.warn('Missing environment values in .env file')
+      }
+
+      this.stripe = new StripeHandler(this);
+      this.paypal = new PayPal(this);
+    },
+
     /**
      * Setup Express middleware
      */
     setupMiddleware() {
       this.app.set("PORT", this.env.NODE_PORT || DEFAULT_PORT);
-
-      this.app.use(this.morgan);
       this.app.use(express.json({ limit: DEFAULT_JSON_LIMIT }));
+      this.app.use(express.urlencoded({ extended: true }));
+      this.app.use(session({
+        secret: process.env.SESSION_SECRET,
+        resave: false,
+        saveUninitialized: false,
+        //store: MongoStore.create({
+          //mongoUrl: process.env.DB_LINK,
+          //touchAfter: 24 * 3600 // lazy session update (24 hours)
+        //}),
+        cookie: {
+          maxAge: 1000 * 60 * 60 * 24 * 7, // 1 week
+          httpOnly: true,
+          secure: process.env.NODE_ENV === 'production' // HTTPS only in production
+        }
+      }));
+      this.app.use(this.morgan);
       this.app.use(compression());
       this.app.use(fileUpload());
       this.app.use(cookieParser());
+      this.app.use(passport.initialize());
+      this.app.use(passport.session()); 
 
-      // Request logging middleware
+      require('./libs/passport');
       this.app.use((req, res, next) => {
         this.logger.info(`FEAR API Query :: ${req.url}`);
-        res.locals.user = req.user;
+        res.locals.user = req.user || null;
         next();
       });
     },
 
+    setupMailer() {
+      const mailService = (this.env.NODE_ENV === 'production') ? 'mailgun' : 'google';
+      const mailinfo = require('./libs/emailer/info');
+      const smtp = require('./libs/emailer/smtp')
+
+      mailinfo.service = mailService;
+      this.mailinfo = mailinfo;
+
+      if ( !this.mailer ) {
+        this.mailer = new smtp(this);
+      }
+    },
     /**
      * Parse allowed origins from environment
      */
@@ -287,6 +298,8 @@ module.exports = FEAR = (() => {
       router.getHandler = () => this.handler;
       router.getValidator = () => this.validator;
       router.getAiAgent = () => this.agentService;
+      router.getStripe = () => this.stripe;
+      router.getPaypal = () => this.paypal;
       //router.getAgentWebInterface = () => this.agentWebInterface;
 
       return router;
@@ -314,14 +327,14 @@ module.exports = FEAR = (() => {
             this.logger.error(`Failed to start server on port ${serverPort}:`, err);
             return reject(err);
           }
-          
+
           this.logger.info(`FEAR server started on port ${serverPort}`);
-          
+
           // Log agent interface status
           if (this.agentWebInterface) {
             this.logger.info(`Agent Web Interface available at ${AGENT_ROUTE_PATH}`);
           }
-          
+
           resolve(this.server);
         });
       });
@@ -347,7 +360,7 @@ module.exports = FEAR = (() => {
           }
 
           // Shutdown agent web interface
-          const agentShutdown = this.agentWebInterface && 
+          const agentShutdown = this.agentWebInterface &&
             typeof this.agentWebInterface.shutdown === 'function' ?
             this.agentWebInterface.shutdown() :
             Promise.resolve();
@@ -397,8 +410,8 @@ module.exports = FEAR = (() => {
         getDatabase: () => this.db,
         getEnvironment: () => this.env,
         getCloud: () => this.cloud,
-        getAiAgent: () => this.agentService,
-        getAgentWebInterface: () => this.agentWebInterface
+        getStripe: () => this.stripe,
+        initProcessors: this.setupProcessors
       };
       return this;
     }

package/FEARServer.js

@@ -2,14 +2,15 @@
 
 const path = require('path');
 const express = require('express');
-require("dotenv").config();
+const fs = require('fs');
+const dotenv = require('dotenv');
 
 const FearServer = (function () {
   // Private constants
   const DEFAULT_PATHS = {
     root: path.resolve(),
-    app: '/backend/dashboard/build',
-    build: 'backend/dashboard/build'
+    app: 'backend/admin/build', 
+    build: 'backend/admin/build'
   };
 
   const DEFAULT_PORT = 4000;
@@ -22,40 +23,170 @@ const FearServer = (function () {
     this.Router = null;
     this.isShuttingDown = false;
     this.rootDir = path.resolve();
+    this.reactApps = []; // Track multiple React apps
+    this.envLoaded = false;
   }
 
   FearServer.prototype = {
     constructor: FearServer,
 
+    /**
+     * Load environment variables from .env file
+     * @param {string|Object} envConfig - Path to .env file or dotenv config object
+     */
+    loadEnv(envConfig) {
+      let envPath;
+      let options = {};
+
+      // Handle different config formats
+      if (typeof envConfig === 'string') {
+        envPath = envConfig;
+      } else if (typeof envConfig === 'object') {
+        envPath = envConfig.path;
+        options = envConfig;
+      }
+
+      // Auto-detect .env file if not specified
+      if (!envPath) {
+        const possiblePaths = [
+          path.join(this.rootDir, '.env'),
+          path.join(this.rootDir, '.env.local'),
+          path.join(this.rootDir, '.env.development'),
+          path.join(this.rootDir, '.env.production'),
+          path.join(process.cwd(), '.env'),
+        ];
+
+        // Check NODE_ENV for environment-specific files
+        if (process.env.NODE_ENV) {
+          possiblePaths.unshift(
+            path.join(this.rootDir, `.env.${process.env.NODE_ENV}`),
+            path.join(this.rootDir, `.env.${process.env.NODE_ENV}.local`)
+          );
+        }
+
+        // Find first existing .env file
+        envPath = possiblePaths.find(p => fs.existsSync(p));
+      }
+
+      if (envPath && !fs.existsSync(envPath)) {
+        console.warn(`⚠️  Warning: .env file not found at ${envPath}`);
+        return false;
+      }
+
+      if (!envPath) {
+        console.warn('Warning: No .env file found in common locations');
+        console.warn('   Checked:', [
+          path.join(this.rootDir, '.env'),
+          path.join(this.rootDir, `.env.${process.env.NODE_ENV || 'development'}`),
+          path.join(process.cwd(), '.env')
+        ]);
+        return false;
+      }
+
+      // Load the .env file
+      const result = dotenv.config({ path: envPath, ...options });
+
+      if (result.error) {
+        console.error('Error loading .env file:', result.error);
+        return false;
+      } 
+
+      this.envLoaded = true;
+      return true;
+    },
+
+    /**
+     * Validate that required files exist for React app
+     * @param {string} buildPath - Path to build directory
+     * @param {string} indexPath - Path to index.html
+     */
+    validateReactApp(buildPath, indexPath) {
+      if (!fs.existsSync(buildPath)) {
+        throw new Error(`Build directory not found: ${buildPath}`);
+      }
+
+      if (!fs.existsSync(indexPath)) {
+        throw new Error(`index.html not found: ${indexPath}`);
+      }
+
+      this.fear.getLogger().info('✓ React app files validated');
+      return true;
+    },
+
     /**
      * Configure static file serving for React SPA
      * @param {string} root - Root directory path
-     * @param {string} app - App directory path
-     * @param {string} build - Build directory path
-     * @param {string} basePath - Base path for the app (e.g., '/fear/sites/ghap')
+     * @param {string} app - App directory path relative to root
+     * @param {string} build - Build directory path for index.html
+     * @param {string} basePath - Base path for the app (e.g., '/admin', '/dashboard')
      */
     setupStaticFiles(root, app, build, basePath = '') {
       this.rootDir = root || path.resolve();
-      const buildPath = path.join(this.rootDir, app);
-      const indexPath = path.resolve(this.rootDir, build, "index.html");
-
+      
+      // Construct paths - handle both absolute and relative paths
+      const buildPath = path.isAbsolute(app) 
+        ? app 
+        : path.join(this.rootDir, app);
+      
+      const indexPath = path.isAbsolute(build)
+        ? path.join(build, "index.html")
+        : path.join(this.rootDir, build, "index.html");
+
+      // Normalize base path
       const normalizedBasePath = basePath
         ? `/${basePath.replace(/^\/+|\/+$/g, '')}`
         : '';
 
-        
-      this.fear.getLogger().info(`Serving static files from: ${buildPath}`);
-      this.fear.getLogger().info(`Base URL path: ${normalizedBasePath || '/'}`);
+      // Debug logging
+      this.fear.getLogger().info('═══════════════════════════════════════');
+      this.fear.getLogger().info('React App Path Resolution:');
+      this.fear.getLogger().info(`→ Build path: ${buildPath}`);
+      this.fear.getLogger().info(`→ Index path: ${indexPath}`);
+      this.fear.getLogger().info(`→ Base path: ${normalizedBasePath || '/'}`);
 
+      // Validate React app exists
+      try {
+        this.validateReactApp(buildPath, indexPath);
+      } catch (error) {
+        this.fear.getLogger().error('React app validation failed:', error.message);
+        throw error;
+      }
+
+      // Serve static files with caching headers
       this.fear.getApp().use(
         normalizedBasePath,
+        (req, res, next) => {
+          this.fear.getLogger().debug(`Static file request: ${req.path}`);
+          next();
+        },
         express.static(buildPath, {
           index: false,
-          fallthrough: true 
+          fallthrough: true,
+          maxAge: '1h', // Cache static assets
+          etag: true,
+          lastModified: true,
+          setHeaders: (res, filePath) => {
+            // Don't cache index.html
+            if (filePath.endsWith('index.html')) {
+              res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
+            }
+            // Cache JS/CSS files aggressively
+            else if (filePath.match(/\.(js|css|woff2?|ttf|eot)$/)) {
+              res.setHeader('Cache-Control', 'public, max-age=31536000, immutable');
+            }
+          }
         })
       );
 
-      this.fear.getApp().get(`${normalizedBasePath}/*`, (req, res) => {
+      this.fear.getApp().get(`${normalizedBasePath}/*`, (req, res, next) => {
+        this.fear.getLogger().debug(`Route request: ${req.path}`);
+        
+        // Skip if it's an API route
+        if (req.path.startsWith('/fear/api')) {
+          this.fear.getLogger().debug('Skipping - API route');
+          return next();
+        }
+
         res.sendFile(indexPath, (err) => {
           if (err) {
             this.fear.getLogger().error('Error serving index.html:', err);
@@ -63,6 +194,85 @@ const FearServer = (function () {
           }
         });
       });
+
+      // Track registered React apps
+      this.reactApps.push({
+        basePath: normalizedBasePath || '/',
+        buildPath,
+        indexPath
+      });
+
+      this.fear.getLogger().info(`React app configured at: ${normalizedBasePath || '/'}`);
+    },
+
+    /**
+     * Add multiple React apps at different base paths
+     * @param {Array} apps - Array of app configurations
+     * Example: [{root: __dirname, app: '/build', build: 'build', basePath: '/admin'}]
+     */
+    setupMultipleReactApps(apps) {
+      if (!Array.isArray(apps)) {
+        throw new Error('setupMultipleReactApps expects an array of app configurations');
+      }
+
+      apps.forEach((appConfig, index) => {
+        this.fear.getLogger().info(`Setting up React app ${index + 1}/${apps.length}`);
+        this.setupStaticFiles(
+          appConfig.root,
+          appConfig.app,
+          appConfig.build,
+          appConfig.basePath
+        );
+      });
+    },
+
+    /**
+     * Setup CORS for React development
+     * @param {Object} options - CORS options
+     */
+    setupCORS(options = {}) {
+      const defaultOptions = {
+        origin: options.origin || '*',
+        methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
+        allowedHeaders: ['Content-Type', 'Authorization'],
+        credentials: options.credentials || false
+      };
+
+      this.fear.getApp().use((req, res, next) => {
+        res.header('Access-Control-Allow-Origin', defaultOptions.origin);
+        res.header('Access-Control-Allow-Methods', defaultOptions.methods.join(', '));
+        res.header('Access-Control-Allow-Headers', defaultOptions.allowedHeaders.join(', '));
+        
+        if (defaultOptions.credentials) {
+          res.header('Access-Control-Allow-Credentials', 'true');
+        }
+
+        // Handle preflight
+        if (req.method === 'OPTIONS') {
+          return res.sendStatus(200);
+        }
+
+        next();
+      });
+
+      this.fear.getLogger().info('CORS configured for React development');
+    },
+
+    /**
+     * Setup API routes prefix (useful to avoid conflicts with React routes)
+     * @param {string} prefix - API prefix (e.g., '/api')
+     */
+    setupAPIPrefix(prefix = '/fear/api') {
+      const normalizedPrefix = `/${prefix.replace(/^\/+|\/+$/g, '')}`;
+      
+      this.fear.getApp().use(normalizedPrefix, (req, res, next) => {
+
+        req.isAPIRoute = true;
+        next();
+      });
+
+      this.fear.getLogger().info(`API routes configured with prefix: ${normalizedPrefix}`);
+      return normalizedPrefix;
     },
 
     /**
@@ -71,9 +281,9 @@ const FearServer = (function () {
     setupProcessHandlers() {
       // Handle unhandled promise rejections
       process.on("unhandledRejection", (reason, promise) => {
-        console.log('Unhandled Rejection at:', promise, 'reason:', reason);
+        console.log('Unhandled Rejection at:', promise);
         this.fear.getLogger().error('Unhandled Rejection at:', promise, 'reason:', reason);
-        //this.gracefulShutdown('unhandledRejection');
+        this.gracefulShutdown('unhandledRejection');
       });
 
       // Handle uncaught exceptions
@@ -183,15 +393,46 @@ const FearServer = (function () {
 
     /**
      * Initialize FEAR application
+     * @param {Object} paths - Path configuration
+     * @param {boolean} ADD_PAYMENTS - Whether to add payment routes
+     * @param {Object} reactConfig - Additional React configuration
+     * @param {string|Object} envConfig - Environment file configuration
      */
-    initialize(paths = DEFAULT_PATHS) {
+    initialize(paths = DEFAULT_PATHS, ADD_PAYMENTS = false, reactConfig = {}, envConfig = null) {
       try {
+        // Set root directory first
+        this.rootDir = paths.root || path.resolve();
+
+        // Load environment variables if config provided
+        if (envConfig) {
+          this.loadEnv(envConfig);
+        } else if (!this.envLoaded) {
+          // Try auto-loading if not already loaded
+          this.loadEnv();
+        }
+
         // Import FEAR after dotenv is configured
         const FearFactory = require("./FEAR");
-        this.fear = new FearFactory();
+        this.fear = new FearFactory({ADD_PAYMENTS});
         this.Router = this.fear.Router;
 
-        this.setupStaticFiles(paths.root, paths.app, paths.build, paths.basePath);
+        // Setup CORS if enabled
+        if (reactConfig.enableCORS) {
+          this.setupCORS(reactConfig.corsOptions);
+        }
+
+        // Setup API prefix if provided
+        if (reactConfig.apiPrefix) {
+          this.setupAPIPrefix(reactConfig.apiPrefix);
+        }
+
+        // Setup React app(s)
+        if (reactConfig.multipleApps && Array.isArray(reactConfig.apps)) {
+          this.setupMultipleReactApps(reactConfig.apps);
+        } else {
+          this.setupStaticFiles(paths.root, paths.app, paths.build, paths.basePath);
+        }
+
         this.setupProcessHandlers();
 
         return Promise.resolve(this.fear);
@@ -213,6 +454,9 @@ const FearServer = (function () {
         logger.warn(this.fear.logo);
       }
 
+      logger.info('Starting FEAR Server...');
+      logger.info('═══════════════════════════════════════');
+
       // Initialize database connection
       return this.initializeDatabase()
         .then(() => {
@@ -221,7 +465,19 @@ const FearServer = (function () {
         })
         .then((server) => {
           this.server = server;
-          logger.info(`FEAR API Initialized :: Port ${port}`);
+          logger.info('═══════════════════════════════════════');
+          logger.info(`FEAR API Server Running on Port ${port}`);
+          logger.info('═══════════════════════════════════════');
+          
+          // Display registered React apps
+          if (this.reactApps.length > 0) {
+            logger.info('📱 React Apps:');
+            this.reactApps.forEach(app => {
+              logger.info(`• http://localhost:${port}${app.basePath}`);
+            });
+            logger.info('═══════════════════════════════════════');
+          }
+
           return server;
         })
         .catch((error) => {
@@ -270,6 +526,20 @@ const FearServer = (function () {
      */
     getRootDir() {
       return this.rootDir;
+    },
+
+    /**
+     * Get registered React apps
+     */
+    getReactApps() {
+      return this.reactApps;
+    },
+
+    /**
+     * Check if environment variables are loaded
+     */
+    isEnvLoaded() {
+      return this.envLoaded;
     }
   };
 

package/controllers/address.js

@@ -0,0 +1,9 @@
+const Address = require("../models/address");
+const methods = require("./crud");
+
+const crud = methods.crudController( Address );
+for(prop in crud) {
+  if(crud.hasOwnProperty(prop)) {
+    module.exports[prop] = crud[prop];
+  }
+}