powr-sdk-api 2.5.3 → 3.0.0

package/dist/config.js

@@ -2,6 +2,7 @@
 
 const config = {
   mongoUri: process.env.POWR_DB_URI,
-  jwtToken: process.env.JWT_TOKEN
+  jwtToken: process.env.JWT_TOKEN,
+  projectId: process.env.PROJECT_ID
 };
 module.exports = config;

package/dist/routes/index.js

@@ -7,6 +7,7 @@ const {
 const {
   verifyToken
 } = require('../middleware/jwtToken');
+const plexxManager = require('../services/plexx');
 
 // Import all route modules
 const commentsRoutes = require('./comments');
@@ -24,9 +25,12 @@ const slidesRoutes = require('./slides');
 const notificationsRoutes = require('./notifications');
 const profilesRoutes = require('./profiles');
 const chatRoutes = require('./chat');
-const createPowrRoutes = (options = {}) => {
+const createPowrRoutes = async (options = {}) => {
   const router = express.Router();
 
+  // Initialize Plexx manager with options
+  await plexxManager.initialize(options);
+
   // Use the dedicated projectId injection middleware
   router.use(injectProjectId(options));
   router.use('/comments', commentsRoutes);

package/dist/routes/plexx.js

@@ -2,15 +2,86 @@
 
 const express = require("express");
 const router = express.Router();
-const {
-  getDb
-} = require("../services/mongo");
+const plexxManager = require("../services/plexx");
+
+// Get Plexx status
+router.get("/status", async (req, res) => {
+  try {
+    const stats = plexxManager.getStats();
+    return res.status(200).json({
+      success: true,
+      data: {
+        ...stats,
+        message: stats.isEnabled ? "Plexx is running" : "Plexx is disabled"
+      }
+    });
+  } catch (err) {
+    console.error("Error getting Plexx status:", err);
+    return res.status(500).json({
+      success: false,
+      message: "Error getting Plexx status"
+    });
+  }
+});
+
+// Enable Plexx
+router.post("/enable", async (req, res) => {
+  try {
+    plexxManager.enable();
+    return res.status(200).json({
+      success: true,
+      message: "Plexx enabled successfully",
+      data: plexxManager.getStats()
+    });
+  } catch (err) {
+    console.error("Error enabling Plexx:", err);
+    return res.status(500).json({
+      success: false,
+      message: "Error enabling Plexx"
+    });
+  }
+});
+
+// Disable Plexx
+router.post("/disable", async (req, res) => {
+  try {
+    plexxManager.disable();
+    return res.status(200).json({
+      success: true,
+      message: "Plexx disabled successfully",
+      data: plexxManager.getStats()
+    });
+  } catch (err) {
+    console.error("Error disabling Plexx:", err);
+    return res.status(500).json({
+      success: false,
+      message: "Error disabling Plexx"
+    });
+  }
+});
+
+// Toggle Plexx
+router.post("/toggle", async (req, res) => {
+  try {
+    const isEnabled = plexxManager.toggle();
+    return res.status(200).json({
+      success: true,
+      message: isEnabled ? "Plexx enabled" : "Plexx disabled",
+      data: plexxManager.getStats()
+    });
+  } catch (err) {
+    console.error("Error toggling Plexx:", err);
+    return res.status(500).json({
+      success: false,
+      message: "Error toggling Plexx"
+    });
+  }
+});
 router.get("/:route", async (req, res) => {
   const {
     route
   } = req.params;
   const {
-    name,
     projectId
   } = req.query;
   if (!projectId) {
@@ -19,23 +90,16 @@ router.get("/:route", async (req, res) => {
       message: 'projectId is required.'
     });
   }
-  const logicEntry = await getDb().collection("routes").findOne({
-    route,
-    projectId
-  });
-  if (!logicEntry) {
-    return res.status(404).json({
-      success: false,
-      message: "Logic not found"
-    });
-  }
-  const codeString = logicEntry.code;
   try {
-    const logicFunction = new Function("age", codeString);
-    const status = logicFunction(name);
+    // Use pre-compiled function (NO COMPILATION HERE)
+    const params = {
+      ...req.query,
+      ...req.body
+    };
+    const result = await plexxManager.execute(projectId, route, params);
     return res.status(200).json({
       success: true,
-      data: status
+      data: result
     });
   } catch (err) {
     console.error("Error executing logic:", err);

package/dist/routes/routes.js

@@ -107,6 +107,8 @@ router.put('/:route', async (req, res) => {
         message: 'Route not found.'
       });
     }
+
+    // Update database
     const result = await db.collection('routes').updateOne(query, {
       $set: {
         code
@@ -118,6 +120,12 @@ router.put('/:route', async (req, res) => {
         message: 'Route not found.'
       });
     }
+
+    // Recompile the updated route using Plexx manager (only if enabled)
+    const plexxManager = require('../services/plexx');
+    if (plexxManager.getStats().isEnabled) {
+      await plexxManager.updateRoute(projectId, route, code);
+    }
     const updatedRoute = await db.collection('routes').findOne(query);
     return res.status(200).json({
       success: true,

package/dist/services/plexx.js

@@ -0,0 +1,181 @@
+"use strict";
+
+const {
+  getDb
+} = require("./mongo");
+const crypto = require('crypto');
+const config = require('../config');
+class PlexxManager {
+  constructor() {
+    this.compiledFunctions = new Map();
+    this.isInitialized = false;
+    this.isCentralService = false;
+    this.isEnabled = false; // Default disabled
+  }
+  async initialize(options = {}) {
+    this.isCentralService = options.isCentralService || false;
+    this.isEnabled = options.enablePlexx === true; // Default false unless explicitly enabled
+
+    if (!this.isEnabled) {
+      console.log("🚫 Plexx is disabled");
+      this.isInitialized = true;
+      return;
+    }
+    if (this.isCentralService) {
+      // Central service: Don't pre-load, load dynamically
+      console.log("🔄 Central service mode - loading routes dynamically");
+      this.isInitialized = true;
+    } else {
+      // Individual API: Load only this project's routes
+      const projectId = config.projectId;
+      console.log(`📦 Loading routes for project: ${projectId}`);
+      try {
+        const routes = await getDb().collection("routes").find({
+          projectId
+        }).toArray();
+        routes.forEach(route => {
+          this.compileAndCache(route);
+        });
+        this.isInitialized = true;
+        console.log(`✅ Pre-compiled ${routes.length} routes for project ${projectId}`);
+      } catch (error) {
+        console.error("❌ Failed to initialize routes:", error);
+        this.isInitialized = true; // Still mark as initialized to prevent blocking
+      }
+    }
+  }
+  compileAndCache(route) {
+    const cacheKey = `${route.projectId}:${route.route}`;
+    try {
+      // Security validation
+      if (!this.validateCode(route.code)) {
+        console.error(`❌ Invalid code in route: ${route.route}`);
+        return;
+      }
+
+      // Pre-compile function
+      const compiledFunction = new Function("params", route.code);
+      this.compiledFunctions.set(cacheKey, {
+        function: compiledFunction,
+        metadata: {
+          route: route.route,
+          projectId: route.projectId,
+          compiledAt: new Date(),
+          codeHash: this.generateHash(route.code)
+        }
+      });
+      console.log(`✅ Compiled: ${route.route}`);
+    } catch (error) {
+      console.error(`❌ Failed to compile ${route.route}:`, error);
+    }
+  }
+  async execute(projectId, route, params) {
+    if (!this.isEnabled) {
+      throw new Error("Plexx is disabled");
+    }
+    const cacheKey = `${projectId}:${route}`;
+    const cached = this.compiledFunctions.get(cacheKey);
+    if (!cached) {
+      if (this.isCentralService) {
+        // Try to load project routes dynamically
+        await this.loadProjectRoutes(projectId);
+        const retryCached = this.compiledFunctions.get(cacheKey);
+        if (retryCached) {
+          return retryCached.function(params);
+        }
+      }
+      throw new Error(`Route not found: ${route}`);
+    }
+    return cached.function(params);
+  }
+
+  // Dynamic loading for central service
+  async loadProjectRoutes(projectId) {
+    if (!this.isCentralService) {
+      throw new Error("Dynamic loading only available in central service mode");
+    }
+    try {
+      const routes = await getDb().collection("routes").find({
+        projectId
+      }).toArray();
+      routes.forEach(route => {
+        this.compileAndCache(route);
+      });
+      console.log(`✅ Loaded ${routes.length} routes for project ${projectId}`);
+    } catch (error) {
+      console.error(`❌ Failed to load routes for project ${projectId}:`, error);
+      throw error;
+    }
+  }
+
+  // Security validation
+  validateCode(code) {
+    const dangerousPatterns = [/process\./, /require\(/, /eval\(/, /setTimeout\(/, /setInterval\(/, /global\./, /__dirname/, /__filename/];
+    return !dangerousPatterns.some(pattern => pattern.test(code));
+  }
+
+  // Generate hash for change detection
+  generateHash(code) {
+    return crypto.createHash('md5').update(code).digest('hex');
+  }
+
+  // Update route (re-compile)
+  async updateRoute(projectId, route, newCode) {
+    const routeData = {
+      projectId,
+      route,
+      code: newCode
+    };
+    this.compileAndCache(routeData);
+
+    // Optionally save to database
+    try {
+      await getDb().collection("routes").updateOne({
+        projectId,
+        route
+      }, {
+        $set: {
+          code: newCode,
+          updatedAt: new Date()
+        }
+      });
+    } catch (error) {
+      console.error(`❌ Failed to update route in database: ${route}`, error);
+    }
+  }
+
+  // Get route statistics
+  getStats() {
+    return {
+      totalRoutes: this.compiledFunctions.size,
+      isInitialized: this.isInitialized,
+      isCentralService: this.isCentralService,
+      isEnabled: this.isEnabled,
+      cacheKeys: Array.from(this.compiledFunctions.keys())
+    };
+  }
+
+  // Clear cache (for testing or maintenance)
+  clearCache() {
+    this.compiledFunctions.clear();
+    console.log("🧹 Route cache cleared");
+  }
+
+  // Enable/Disable Plexx
+  enable() {
+    this.isEnabled = true;
+    console.log("✅ Plexx enabled");
+  }
+  disable() {
+    this.isEnabled = false;
+    console.log("🚫 Plexx disabled");
+  }
+
+  // Toggle Plexx
+  toggle() {
+    this.isEnabled = !this.isEnabled;
+    console.log(this.isEnabled ? "✅ Plexx enabled" : "🚫 Plexx disabled");
+    return this.isEnabled;
+  }
+}
+module.exports = new PlexxManager();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "powr-sdk-api",
-  "version": "2.5.3",
+  "version": "3.0.0",
   "description": "Shared API core library for PowrStack projects",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",