powr-sdk-api 3.0.6 → 3.0.8

package/dist/index.js

@@ -15,7 +15,7 @@ const {
 } = require("./swagger");
 const {
   createPowrRoutes,
-  initializePlexx
+  initializeFunctions
 } = require("./routes");
 const {
   verifyToken
@@ -27,6 +27,6 @@ module.exports = {
   createSwaggerSpec,
   notFoundHandler,
   createPowrRoutes,
-  initializePlexx,
+  initializeFunctions,
   verifyToken
 };

package/dist/routes/functions.js

@@ -0,0 +1,269 @@
+"use strict";
+
+const express = require("express");
+const router = express.Router();
+const functionsManager = require("../services/functions");
+const {
+  getDb
+} = require("../services/mongo");
+
+// Get Functions status
+router.get("/status", async (req, res) => {
+  try {
+    const stats = functionsManager.getStats();
+    return res.status(200).json({
+      success: true,
+      data: {
+        ...stats,
+        message: stats.isEnabled ? "Functions is running" : "Functions is disabled"
+      }
+    });
+  } catch (err) {
+    console.error("Error getting Functions status:", err);
+    return res.status(500).json({
+      success: false,
+      message: "Error getting Functions status"
+    });
+  }
+});
+
+// Enable Functions
+router.post("/enable", async (req, res) => {
+  try {
+    functionsManager.enable();
+    return res.status(200).json({
+      success: true,
+      message: "Functions enabled successfully",
+      data: functionsManager.getStats()
+    });
+  } catch (err) {
+    console.error("Error enabling Functions:", err);
+    return res.status(500).json({
+      success: false,
+      message: "Error enabling Functions"
+    });
+  }
+});
+
+// Disable Functions
+router.post("/disable", async (req, res) => {
+  try {
+    functionsManager.disable();
+    return res.status(200).json({
+      success: true,
+      message: "Functions disabled successfully",
+      data: functionsManager.getStats()
+    });
+  } catch (err) {
+    console.error("Error disabling Functions:", err);
+    return res.status(500).json({
+      success: false,
+      message: "Error disabling Functions"
+    });
+  }
+});
+
+// Toggle Functions
+router.post("/toggle", async (req, res) => {
+  try {
+    const isEnabled = functionsManager.toggle();
+    return res.status(200).json({
+      success: true,
+      message: isEnabled ? "Functions enabled" : "Functions disabled",
+      data: functionsManager.getStats()
+    });
+  } catch (err) {
+    console.error("Error toggling Functions:", err);
+    return res.status(500).json({
+      success: false,
+      message: "Error toggling Functions"
+    });
+  }
+});
+
+// CRUD Operations for Functions
+
+// Get all functions entries
+router.get('/', async (req, res) => {
+  const {
+    projectId
+  } = req.query;
+  try {
+    const query = {
+      projectId
+    };
+    if (!projectId) {
+      return res.status(400).json({
+        success: false,
+        message: 'projectId is required.'
+      });
+    }
+    const db = await getDb();
+    const functionsData = await db.collection("functions").find(query).toArray();
+    return res.status(200).json({
+      success: true,
+      allfunctions: functionsData
+    });
+  } catch (error) {
+    console.error("Error retrieving functions entries:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to retrieve functions entries."
+    });
+  }
+});
+
+// Create a new function 
+router.post('/', async (req, res) => {
+  try {
+    const {
+      projectId
+    } = req.query;
+    if (!projectId) {
+      return res.status(400).json({
+        success: false,
+        message: 'projectId is required.'
+      });
+    }
+    const newFunction = req.body;
+    newFunction.projectId = projectId;
+    if (!newFunction || Object.keys(newFunction).length === 0) {
+      return res.status(400).json({
+        success: false,
+        message: 'Request body is empty or invalid.'
+      });
+    }
+    const db = await getDb();
+    const result = await db.collection('functions').insertOne(newFunction);
+
+    // Recompile the new function using Functions manager (only if enabled)
+    if (functionsManager.getStats().isEnabled) {
+      await functionsManager.updateRoute(projectId, newFunction.route, newFunction.code);
+    }
+    return res.status(201).json({
+      success: true,
+      entry: result.ops ? result.ops[0] : newFunction
+    });
+  } catch (error) {
+    console.error('Error inserting function entry:', error);
+    return res.status(500).json({
+      success: false,
+      message: 'Failed to insert function entry.'
+    });
+  }
+});
+
+// Update function code
+router.put('/:function', async (req, res) => {
+  try {
+    const {
+      function: functionName
+    } = req.params;
+    const {
+      code
+    } = req.body;
+    const {
+      projectId
+    } = req.query;
+    if (!projectId) {
+      return res.status(400).json({
+        success: false,
+        message: 'projectId is required.'
+      });
+    }
+    if (!code) {
+      return res.status(400).json({
+        success: false,
+        message: 'Code field is required.'
+      });
+    }
+    const query = {
+      route: functionName,
+      projectId
+    };
+    const db = await getDb();
+    const existingFunction = await db.collection('functions').findOne(query);
+    if (!existingFunction) {
+      return res.status(404).json({
+        success: false,
+        message: 'Function not found.'
+      });
+    }
+
+    // Update database
+    const result = await db.collection('functions').updateOne(query, {
+      $set: {
+        code
+      }
+    });
+    if (result.matchedCount === 0) {
+      return res.status(404).json({
+        success: false,
+        message: 'Function not found.'
+      });
+    }
+
+    // Recompile the updated function using Functions manager (only if enabled)
+    if (functionsManager.getStats().isEnabled) {
+      await functionsManager.updateRoute(projectId, functionName, code);
+    }
+    const updatedFunction = await db.collection('functions').findOne(query);
+    return res.status(200).json({
+      success: true,
+      entry: updatedFunction
+    });
+  } catch (error) {
+    console.error('Error updating function code:', error);
+    return res.status(500).json({
+      success: false,
+      message: 'Failed to update function code.',
+      error: error.message
+    });
+  }
+});
+
+// Execute dynamic function
+router.post("/:function", async (req, res) => {
+  const {
+    function: functionName
+  } = req.params;
+  const {
+    projectId
+  } = req.query;
+  if (!projectId) {
+    return res.status(400).json({
+      success: false,
+      message: 'projectId is required.'
+    });
+  }
+  try {
+    // Use pre-compiled function (NO COMPILATION HERE)
+    const params = {
+      ...req.query,
+      ...req.body
+    };
+    const result = await functionsManager.execute(projectId, functionName, params);
+
+    // Handle the standardized response format
+    if (result.success) {
+      return res.status(200).json({
+        success: true,
+        data: result.data,
+        message: result.message
+      });
+    } else {
+      return res.status(404).json({
+        success: false,
+        message: result.message,
+        data: result.data
+      });
+    }
+  } catch (err) {
+    console.error("Error executing function:", err);
+    return res.status(500).json({
+      success: false,
+      message: "Error executing function"
+    });
+  }
+});
+module.exports = router;

package/dist/routes/index.js

@@ -7,7 +7,7 @@ const {
 const {
   verifyToken
 } = require('../middleware/jwtToken');
-const plexxManager = require('../services/plexx');
+const functionsManager = require('../services/functions');
 
 // Import all route modules
 const commentsRoutes = require('./comments');
@@ -15,7 +15,7 @@ const filesRoutes = require('./files');
 const formsRoutes = require('./forms');
 const invoiceRoutes = require('./invoice');
 const likesRoutes = require('./likes');
-const plexxRoutes = require('./plexx');
+const functionsRoutes = require('./functions');
 const ratingsRoutes = require('./ratings');
 const usersRoutes = require('./users');
 const waitlistsRoutes = require('./waitlists');
@@ -37,7 +37,7 @@ const createPowrRoutes = (options = {}) => {
   router.use('/forms', formsRoutes);
   router.use('/invoice', invoiceRoutes);
   router.use('/likes', likesRoutes);
-  router.use('/plexx', plexxRoutes);
+  router.use('/functions', functionsRoutes);
   router.use('/ratings', ratingsRoutes);
   router.use('/users', usersRoutes);
   router.use('/waitlists', waitlistsRoutes);
@@ -50,12 +50,12 @@ const createPowrRoutes = (options = {}) => {
   return router;
 };
 
-// Async Plexx initialization function
-const initializePlexx = async (options = {}) => {
-  // Initialize Plexx manager with options
-  await plexxManager.initialize(options);
+// Async Functions initialization function
+const initializeFunctions = async (options = {}) => {
+  // Initialize Functions manager with options
+  await functionsManager.initialize(options);
 };
 module.exports = {
   createPowrRoutes,
-  initializePlexx
+  initializeFunctions
 };

package/dist/routes/users.js

@@ -23,7 +23,8 @@ router.post("/", verifyToken, async (req, res) => {
 
   try {
     // Check if user already exists
-    const existingUser = await getDb().collection("users").findOne({
+    const db = await getDb();
+    const existingUser = await db.collection("users").findOne({
       $or: [{
         phoneNumber
       }, {
@@ -43,7 +44,7 @@ router.post("/", verifyToken, async (req, res) => {
       createdAt: new Date(),
       updatedAt: new Date()
     };
-    const result = await getDb().collection("users").insertOne(newUser);
+    const result = await db.collection("users").insertOne(newUser);
 
     // Create profile for this project
     const newProfile = {
@@ -53,7 +54,7 @@ router.post("/", verifyToken, async (req, res) => {
       createdAt: new Date(),
       updatedAt: new Date()
     };
-    await getDb().collection("profiles").insertOne(newProfile);
+    await db.collection("profiles").insertOne(newProfile);
     return res.status(201).json({
       success: true,
       message: "User created successfully",
@@ -90,11 +91,12 @@ router.get("/", verifyToken, async (req, res) => {
     if (email) {
       query.email = email;
     }
-    const users = await getDb().collection("users").find(query).toArray();
+    const db = await getDb();
+    const users = await db.collection("users").find(query).toArray();
 
     // Get profiles for this project
     const userIds = users.map(user => user._id);
-    const profiles = await getDb().collection("profiles").find({
+    const profiles = await db.collection("profiles").find({
       userId: {
         $in: userIds
       },
@@ -137,7 +139,8 @@ router.put("/:id", verifyToken, async (req, res) => {
 
   try {
     // Check if user exists
-    const existingUser = await getDb().collection("users").findOne({
+    const db = await getDb();
+    const existingUser = await db.collection("users").findOne({
       _id: new ObjectId(id)
     });
     if (!existingUser) {
@@ -154,7 +157,7 @@ router.put("/:id", verifyToken, async (req, res) => {
       email,
       updatedAt: new Date()
     };
-    await getDb().collection("users").updateOne({
+    await db.collection("users").updateOne({
       _id: new ObjectId(id)
     }, {
       $set: updateData
@@ -162,7 +165,7 @@ router.put("/:id", verifyToken, async (req, res) => {
 
     // Update profile if access level is provided
     if (userData.access !== undefined) {
-      await getDb().collection("profiles").updateOne({
+      await db.collection("profiles").updateOne({
         userId: new ObjectId(id),
         projectId: projectId
       }, {
@@ -196,7 +199,8 @@ router.delete("/:id", verifyToken, async (req, res) => {
 
   try {
     // Check if user exists
-    const existingUser = await getDb().collection("users").findOne({
+    const db = await getDb();
+    const existingUser = await db.collection("users").findOne({
       _id: new ObjectId(id)
     });
     if (!existingUser) {
@@ -207,12 +211,12 @@ router.delete("/:id", verifyToken, async (req, res) => {
     }
 
     // Delete user
-    await getDb().collection("users").deleteOne({
+    await db.collection("users").deleteOne({
       _id: new ObjectId(id)
     });
 
     // Delete profile for this project
-    await getDb().collection("profiles").deleteOne({
+    await db.collection("profiles").deleteOne({
       userId: new ObjectId(id),
       projectId: projectId
     });

package/dist/routes/waitlists.js

@@ -14,7 +14,8 @@ router.get("/", async (req, res) => {
   const projectId = req.projectId; // Use middleware-injected projectId
 
   try {
-    const waitlists = await getDb().collection("waitlists").find({
+    const db = await getDb();
+    const waitlists = await db.collection("waitlists").find({
       projectId
     }).toArray();
     return res.json({

package/dist/services/functions.js

@@ -0,0 +1,229 @@
+"use strict";
+
+const {
+  getDb
+} = require("./mongo");
+const crypto = require('crypto');
+const config = require('../config');
+class FunctionsManager {
+  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.enableFunctions === true; // Default false unless explicitly enabled
+
+    if (!this.isEnabled) {
+      console.log("🚫 Functions is disabled");
+      this.isInitialized = true;
+      return;
+    }
+    if (this.isCentralService) {
+      // Central service: Don't pre-load, load dynamically
+      console.log("🔄 Central service mode - loading functions dynamically");
+      this.isInitialized = true;
+    } else {
+      // Individual API: Load only this project's functions
+      const projectId = config.projectId;
+      console.log(`📦 Loading functions for project: ${projectId}`);
+      try {
+        const db = await getDb();
+        const routes = await db.collection("functions").find({
+          projectId
+        }).toArray();
+        routes.forEach(route => {
+          this.compileAndCache(route);
+        });
+        this.isInitialized = true;
+        console.log(`✅ Pre-compiled ${routes.length} functions for project ${projectId}`);
+      } catch (error) {
+        console.error("❌ Failed to initialize functions:", 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 function: ${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) {
+      return {
+        success: false,
+        message: "Functions is disabled",
+        data: null
+      };
+    }
+    const cacheKey = `${projectId}:${route}`;
+    const cached = this.compiledFunctions.get(cacheKey);
+    if (!cached) {
+      if (this.isCentralService) {
+        // Try to load only the specific function dynamically
+        await this.loadSpecificRoute(projectId, route);
+        const retryCached = this.compiledFunctions.get(cacheKey);
+        if (retryCached) {
+          return retryCached.function(params);
+        }
+      }
+      return {
+        success: false,
+        message: `Function not found: ${route}`,
+        data: null
+      };
+    }
+    try {
+      const result = cached.function(params);
+      return {
+        success: true,
+        message: "Function executed successfully",
+        data: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Error executing function: ${error.message}`,
+        data: null,
+        error: error.message
+      };
+    }
+  }
+
+  // Load specific function for central service
+  async loadSpecificRoute(projectId, route) {
+    if (!this.isCentralService) {
+      throw new Error("Dynamic loading only available in central service mode");
+    }
+    try {
+      const db = await getDb();
+      const routeData = await db.collection("functions").findOne({
+        projectId,
+        route
+      });
+      if (routeData) {
+        this.compileAndCache(routeData);
+        console.log(`✅ Loaded function: ${route} for project ${projectId}`);
+      } else {
+        console.log(`❌ Function not found: ${route} for project ${projectId}`);
+      }
+    } catch (error) {
+      console.error(`❌ Failed to load function ${route} for project ${projectId}:`, error);
+      throw error;
+    }
+  }
+
+  // Dynamic loading for central service
+  async loadProjectRoutes(projectId) {
+    if (!this.isCentralService) {
+      throw new Error("Dynamic loading only available in central service mode");
+    }
+    try {
+      const db = await getDb();
+      const routes = await db.collection("functions").find({
+        projectId
+      }).toArray();
+      routes.forEach(route => {
+        this.compileAndCache(route);
+      });
+      console.log(`✅ Loaded ${routes.length} functions for project ${projectId}`);
+    } catch (error) {
+      console.error(`❌ Failed to load functions 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 function (re-compile)
+  async updateRoute(projectId, route, newCode) {
+    const routeData = {
+      projectId,
+      route,
+      code: newCode
+    };
+    this.compileAndCache(routeData);
+
+    // Optionally save to database
+    try {
+      const db = await getDb();
+      await db.collection("functions").updateOne({
+        projectId,
+        route
+      }, {
+        $set: {
+          code: newCode,
+          updatedAt: new Date()
+        }
+      });
+    } catch (error) {
+      console.error(`❌ Failed to update function in database: ${route}`, error);
+    }
+  }
+
+  // Get function statistics
+  getStats() {
+    return {
+      totalFunctions: 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("🧹 Function cache cleared");
+  }
+
+  // Enable/Disable Functions
+  enable() {
+    this.isEnabled = true;
+    console.log("✅ Functions enabled");
+  }
+  disable() {
+    this.isEnabled = false;
+    console.log("🚫 Functions disabled");
+  }
+
+  // Toggle Functions
+  toggle() {
+    this.isEnabled = !this.isEnabled;
+    console.log(this.isEnabled ? "✅ Functions enabled" : "🚫 Functions disabled");
+    return this.isEnabled;
+  }
+}
+module.exports = new FunctionsManager();

package/package.json

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