powr-sdk-api 4.3.12 → 4.3.13

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/dist/services/logger.js

@@ -0,0 +1,35 @@
+"use strict";
+
+const winston = require('winston');
+const {
+  S3Transport
+} = require('../utils/s3');
+
+// Custom format for logs
+const logFormat = winston.format.combine(winston.format.timestamp(), winston.format.errors({
+  stack: true
+}), winston.format.json());
+
+// Create base transports array with console transport
+const transports = [new winston.transports.Console()];
+
+// Add S3 transport only in production
+if (process.env.NODE_ENV === 'production') {
+  transports.push(new S3Transport({
+    bucket: process.env.AWS_LOG_BUCKET_NAME,
+    prefix: 'logs',
+    bufferSize: 100,
+    flushInterval: 5000
+  }));
+}
+
+// Create the logger
+const logger = winston.createLogger({
+  level: process.env.LOG_LEVEL || 'info',
+  format: logFormat,
+  defaultMeta: {
+    service: process.env.LOG_SERVICE_NAME
+  },
+  transports
+});
+module.exports = logger;

package/dist/services/plexx.js

@@ -0,0 +1,229 @@
+"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 db = await getDb();
+        const routes = await db.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) {
+      return {
+        success: false,
+        message: "Plexx 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 route dynamically
+        await this.loadSpecificRoute(projectId, route);
+        const retryCached = this.compiledFunctions.get(cacheKey);
+        if (retryCached) {
+          return retryCached.function(params);
+        }
+      }
+      return {
+        success: false,
+        message: `Route not found: ${route}`,
+        data: null
+      };
+    }
+    try {
+      const result = cached.function(params);
+      return {
+        success: true,
+        message: "Route executed successfully",
+        data: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Error executing route: ${error.message}`,
+        data: null,
+        error: error.message
+      };
+    }
+  }
+
+  // Load specific route 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("routes").findOne({
+        projectId,
+        route
+      });
+      if (routeData) {
+        this.compileAndCache(routeData);
+        console.log(`✅ Loaded route: ${route} for project ${projectId}`);
+      } else {
+        console.log(`❌ Route not found: ${route} for project ${projectId}`);
+      }
+    } catch (error) {
+      console.error(`❌ Failed to load route ${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("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 {
+      const db = await getDb();
+      await db.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/dist/utils/auth.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const jwt = require('jsonwebtoken');
+
+/**
+ * Generates a JWT token for a user
+ * @param {Object} user - The user object
+ * @returns {string} - The generated JWT token
+ */
+const generateToken = user => {
+  return jwt.sign({
+    userId: user.userId
+  }, process.env.JWT_SECRET, {
+    expiresIn: process.env.JWT_EXPIRES_IN || '24h'
+  });
+};
+module.exports = {
+  generateToken
+};

package/dist/utils/logger.js

@@ -0,0 +1,57 @@
+"use strict";
+
+/**
+ * Logger utility for Express applications
+ */
+
+const winston = require('winston');
+const S3Transport = require('./s3-transport');
+
+/**
+ * Creates a Winston logger instance with configured transports
+ * @param {Object} options - Logger configuration options
+ * @param {string} options.service - Service name for logging
+ * @param {string} options.level - Log level (default: 'info')
+ * @param {Object} options.s3 - S3 transport configuration
+ * @param {string} options.s3.bucket - S3 bucket name
+ * @param {string} options.s3.prefix - S3 key prefix
+ * @param {number} options.s3.bufferSize - Buffer size for S3 uploads
+ * @param {number} options.s3.flushInterval - Flush interval in milliseconds
+ * @returns {winston.Logger} Configured Winston logger instance
+ */
+const createLogger = (options = {}) => {
+  const {
+    service = 'api',
+    level = process.env.LOG_LEVEL || 'info',
+    s3 = null
+  } = options;
+
+  // Custom format for logs
+  const logFormat = winston.format.combine(winston.format.timestamp(), winston.format.errors({
+    stack: true
+  }), winston.format.json());
+
+  // Create base transports array with console transport
+  const transports = [new winston.transports.Console()];
+
+  // Add S3 transport if configured
+  if (s3 && process.env.NODE_ENV === 'production') {
+    transports.push(new S3Transport({
+      bucket: s3.bucket,
+      prefix: s3.prefix || 'logs',
+      bufferSize: s3.bufferSize || 100,
+      flushInterval: s3.flushInterval || 5000
+    }));
+  }
+
+  // Create and return the logger
+  return winston.createLogger({
+    level,
+    format: logFormat,
+    defaultMeta: {
+      service
+    },
+    transports
+  });
+};
+module.exports = createLogger;

package/dist/utils/s3-transport.js

@@ -0,0 +1,61 @@
+"use strict";
+
+/**
+ * S3 Transport for Winston logger
+ */
+
+const winston = require('winston');
+const {
+  S3Client,
+  PutObjectCommand
+} = require('@aws-sdk/client-s3');
+
+/**
+ * Custom Winston transport for logging to S3
+ */
+class S3Transport extends winston.Transport {
+  constructor(opts) {
+    super(opts);
+    this.bucket = opts.bucket;
+    this.prefix = opts.prefix || '';
+    this.buffer = [];
+    this.bufferSize = opts.bufferSize || 100;
+    this.flushInterval = opts.flushInterval || 5000;
+    this.setupFlushInterval();
+  }
+  setupFlushInterval() {
+    setInterval(() => {
+      this.flush();
+    }, this.flushInterval);
+  }
+  async flush() {
+    if (this.buffer.length === 0) return;
+    const logs = this.buffer.splice(0, this.buffer.length);
+    const date = new Date().toISOString().split('T')[0];
+    const key = `${this.prefix}/${date}/${Date.now()}.json`;
+    try {
+      const command = new PutObjectCommand({
+        Bucket: this.bucket,
+        Key: key,
+        Body: JSON.stringify(logs),
+        ContentType: 'application/json'
+      });
+      await this.s3Client.send(command);
+    } catch (error) {
+      console.error('Error flushing logs to S3:', error);
+      // Put logs back in buffer
+      this.buffer.unshift(...logs);
+    }
+  }
+  log(info, callback) {
+    setImmediate(() => {
+      this.emit('logged', info);
+    });
+    this.buffer.push(info);
+    if (this.buffer.length >= this.bufferSize) {
+      this.flush();
+    }
+    callback();
+  }
+}
+module.exports = S3Transport;

package/dist/utils/s3.js

@@ -0,0 +1,78 @@
+"use strict";
+
+const winston = require('winston');
+const {
+  S3Client,
+  PutObjectCommand
+} = require('@aws-sdk/client-s3');
+
+// Create S3 client
+const s3Client = new S3Client({
+  region: process.env.AWS_REGION,
+  credentials: {
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
+  }
+});
+
+/**
+ * Custom Winston transport for logging to S3
+ */
+class S3Transport extends winston.Transport {
+  constructor(opts) {
+    super(opts);
+    this.bucket = opts.bucket;
+    this.prefix = opts.prefix || '';
+    this.buffer = [];
+    this.bufferSize = opts.bufferSize || 100;
+    this.flushInterval = opts.flushInterval || 5000;
+    this.setupFlushInterval();
+  }
+  setupFlushInterval() {
+    setInterval(() => {
+      this.flush();
+    }, this.flushInterval);
+  }
+  async flush() {
+    if (this.buffer.length === 0) return;
+    const logs = this.buffer.splice(0, this.buffer.length);
+    const date = new Date().toISOString().split('T')[0];
+    const key = `${this.prefix}/${date}/${Date.now()}.json`;
+    try {
+      const command = new PutObjectCommand({
+        Bucket: this.bucket,
+        Key: key,
+        Body: JSON.stringify(logs),
+        ContentType: 'application/json'
+      });
+      await s3Client.send(command);
+    } catch (error) {
+      console.error('Failed to write logs to S3:', {
+        error: error.message,
+        code: error.code,
+        bucket: this.bucket,
+        key: key,
+        region: process.env.AWS_REGION,
+        stack: error.stack
+      });
+      // Put the logs back in the buffer
+      this.buffer.unshift(...logs);
+    }
+  }
+  log(info, callback) {
+    setImmediate(() => {
+      this.emit('logged', info);
+    });
+    this.buffer.push({
+      timestamp: new Date().toISOString(),
+      ...info
+    });
+    if (this.buffer.length >= this.bufferSize) {
+      this.flush();
+    }
+    callback();
+  }
+}
+module.exports = {
+  S3Transport
+};