powr-sdk-api 4.1.10 → 4.3.0

package/dist/index.js

@@ -14,11 +14,13 @@ const {
   createSwaggerSpec
 } = require("./swagger");
 const {
-  createPowrRoutes,
+  createPowrRoutes
+} = require("./routes");
+const {
   initializeFunctions,
   initializeTools,
-  initializeScheduledTasks
-} = require("./routes");
+  executeTasks
+} = require("./managers");
 const {
   verifyToken
 } = require("./middleware/jwtToken");
@@ -31,6 +33,6 @@ module.exports = {
   createPowrRoutes,
   initializeFunctions,
   initializeTools,
-  initializeScheduledTasks,
-  verifyToken
+  verifyToken,
+  executeTasks
 };

package/dist/{services → managers}/functions.js

@@ -2,7 +2,7 @@
 
 const {
   getDb
-} = require("./mongo");
+} = require("../services/mongo");
 const crypto = require('crypto');
 const config = require('../config');
 class FunctionsManager {

package/dist/managers/index.js

@@ -0,0 +1,26 @@
+"use strict";
+
+const functionsManager = require('./functions');
+const toolsManager = require('./tools');
+const scheduledTasksManager = require('./tasks');
+
+// Async Functions initialization function
+const initializeFunctions = async (options = {}) => {
+  // Initialize Functions manager with options
+  await functionsManager.initialize(options);
+};
+
+// Async Tools initialization function
+const initializeTools = async (options = {}) => {
+  // Initialize Tools manager with options
+  await toolsManager.initialize(options);
+};
+module.exports = {
+  // Managers
+  functionsManager,
+  toolsManager,
+  scheduledTasksManager,
+  // Initialization/Execution methods
+  initializeFunctions,
+  initializeTools
+};

package/dist/{services/scheduledTasks.js → managers/tasks.js}

@@ -2,64 +2,44 @@
 
 const {
   getDb
-} = require("./mongo");
-const cron = require('node-cron');
+} = require("../services/mongo");
 class ScheduledTasksManager {
-  constructor() {
-    this.scheduledJobs = new Map();
-    this.isInitialized = false;
-  }
-  async initialize() {
-    try {
-      console.log("📅 Initializing scheduled tasks manager...");
-
-      // Load existing tasks from database
-      const db = await getDb();
-      const tasks = await db.collection("scheduled_tasks").find({
-        isActive: true
-      }).toArray();
-
-      // Schedule existing active tasks
-      tasks.forEach(task => {
-        this.scheduleTask(task);
-      });
-      this.isInitialized = true;
-      console.log(`✅ Scheduled ${tasks.length} active tasks`);
-    } catch (error) {
-      console.error("❌ Failed to initialize scheduled tasks:", error);
-      this.isInitialized = true; // Still mark as initialized
-    }
-  }
-
   // Create a new scheduled task
   async createTask(taskData) {
     try {
       const db = await getDb();
       const task = {
-        id: taskData.id || this.generateTaskId(),
         name: taskData.name,
         description: taskData.description,
-        cronExpression: taskData.cronExpression,
         toolId: taskData.toolId,
         actionId: taskData.actionId,
         params: taskData.params,
         userId: taskData.userId,
         projectId: taskData.projectId,
-        // Add projectId
         isActive: taskData.isActive !== false,
         // Default to true
-        lastRun: null,
-        nextRun: this.getNextRunTime(taskData.cronExpression),
+        scheduledFor: taskData.scheduledFor,
+        // null, timestamp, or cron expression
+        nextRun: null,
+        // Will be calculated based on scheduling type
         createdAt: new Date(),
         updatedAt: new Date()
       };
-      await db.collection("scheduled_tasks").insertOne(task);
 
-      // Schedule the task if it's active
-      if (task.isActive) {
-        this.scheduleTask(task);
+      // Calculate nextRun based on scheduling type
+      if (!task.scheduledFor) {
+        // Immediate execution - run on next Atlas trigger
+        task.nextRun = new Date();
+      } else if (this.isTimestamp(task.scheduledFor)) {
+        // One-time execution - run at the specified time
+        task.nextRun = new Date(task.scheduledFor);
+      } else if (this.isCronExpression(task.scheduledFor)) {
+        // Recurring execution - calculate next run from cron
+        task.nextRun = this.getNextRunTime(task.scheduledFor);
       }
+      await db.collection("tasks").insertOne(task);
       console.log(`✅ Created scheduled task: ${task.name} (${task.id})`);
+      console.log(`📅 Next run: ${task.nextRun}`);
       return {
         success: true,
         task
@@ -88,7 +68,7 @@ class ScheduledTasksManager {
         query.userId = userId;
         query.projectId = projectId;
       }
-      const tasks = await db.collection("scheduled_tasks").find(query).sort({
+      const tasks = await db.collection("tasks").find(query).sort({
         createdAt: -1
       }).toArray();
       return {
@@ -121,7 +101,7 @@ class ScheduledTasksManager {
         query.userId = userId;
         query.projectId = projectId;
       }
-      const task = await db.collection("scheduled_tasks").findOne(query);
+      const task = await db.collection("tasks").findOne(query);
       if (!task) {
         return {
           success: false,
@@ -142,7 +122,7 @@ class ScheduledTasksManager {
   }
 
   // Update a task (with project and user validation)
-  async updateTask(taskId, userId, projectId, updates, isAdmin = false) {
+  async updateTask(taskId, userId, projectId, updateData, isAdmin = false) {
     try {
       const db = await getDb();
 
@@ -158,42 +138,31 @@ class ScheduledTasksManager {
         query.userId = userId;
         query.projectId = projectId;
       }
-
-      // Get existing task
-      const existingTask = await db.collection("scheduled_tasks").findOne(query);
-      if (!existingTask) {
+      const task = await db.collection("tasks").findOne(query);
+      if (!task) {
         return {
           success: false,
           message: "Task not found"
         };
       }
 
-      // Update fields
-      const updatedTask = {
-        ...existingTask,
-        ...updates,
-        updatedAt: new Date()
-      };
-
-      // Update next run time if cron expression changed
-      if (updates.cronExpression && updates.cronExpression !== existingTask.cronExpression) {
-        updatedTask.nextRun = this.getNextRunTime(updates.cronExpression);
-      }
-      await db.collection("scheduled_tasks").updateOne(query, {
-        $set: updatedTask
+      // Update the task
+      const updateResult = await db.collection("tasks").updateOne(query, {
+        $set: {
+          ...updateData,
+          updatedAt: new Date(),
+          nextRun: updateData.scheduledFor ? this.getNextRunTime(updateData.scheduledFor) : task.nextRun
+        }
       });
-
-      // Reschedule if active
-      if (updatedTask.isActive) {
-        this.unscheduleTask(taskId);
-        this.scheduleTask(updatedTask);
-      } else {
-        this.unscheduleTask(taskId);
+      if (updateResult.modifiedCount === 0) {
+        return {
+          success: false,
+          message: "Failed to update task"
+        };
       }
-      console.log(`✅ Updated scheduled task: ${updatedTask.name} (${taskId})`);
+      console.log(`✅ Updated scheduled task: ${taskId}`);
       return {
-        success: true,
-        task: updatedTask
+        success: true
       };
     } catch (error) {
       console.error("❌ Failed to update scheduled task:", error);
@@ -223,7 +192,7 @@ class ScheduledTasksManager {
       }
 
       // Get task to check if it exists
-      const task = await db.collection("scheduled_tasks").findOne(query);
+      const task = await db.collection("tasks").findOne(query);
       if (!task) {
         return {
           success: false,
@@ -232,10 +201,10 @@ class ScheduledTasksManager {
       }
 
       // Remove from database
-      await db.collection("scheduled_tasks").deleteOne(query);
+      await db.collection("tasks").deleteOne(query);
+
+      // No need to unschedule - MongoDB Atlas will handle this automatically
 
-      // Unschedule the task
-      this.unscheduleTask(taskId);
       console.log(`✅ Deleted scheduled task: ${task.name} (${taskId})`);
       return {
         success: true
@@ -266,36 +235,23 @@ class ScheduledTasksManager {
         query.userId = userId;
         query.projectId = projectId;
       }
-      const task = await db.collection("scheduled_tasks").findOne(query);
+      const task = await db.collection("tasks").findOne(query);
       if (!task) {
         return {
           success: false,
           message: "Task not found"
         };
       }
-      if (isActive) {
-        // Activate task
-        await db.collection("scheduled_tasks").updateOne(query, {
-          $set: {
-            isActive: true,
-            updatedAt: new Date()
-          }
-        });
-        this.scheduleTask({
-          ...task,
-          isActive: true
-        });
-      } else {
-        // Deactivate task
-        await db.collection("scheduled_tasks").updateOne(query, {
-          $set: {
-            isActive: false,
-            updatedAt: new Date()
-          }
-        });
-        this.unscheduleTask(taskId);
-      }
+
+      // Update active status
+      await db.collection("tasks").updateOne(query, {
+        $set: {
+          isActive: isActive,
+          updatedAt: new Date()
+        }
+      });
       console.log(`${isActive ? '✅' : '❌'} Task ${taskId} ${isActive ? 'activated' : 'deactivated'}`);
+      console.log(`📅 MongoDB Atlas Scheduled Trigger will ${isActive ? 'start' : 'stop'} executing this task.`);
       return {
         success: true
       };
@@ -325,7 +281,7 @@ class ScheduledTasksManager {
         query.userId = userId;
         query.projectId = projectId;
       }
-      const task = await db.collection("scheduled_tasks").findOne(query);
+      const task = await db.collection("tasks").findOne(query);
       if (!task) {
         return {
           success: false,
@@ -336,13 +292,6 @@ class ScheduledTasksManager {
 
       // Execute the task
       const result = await this.executeTaskAction(task);
-
-      // Update last run time
-      await db.collection("scheduled_tasks").updateOne(query, {
-        $set: {
-          lastRun: new Date()
-        }
-      });
       return {
         success: true,
         result
@@ -356,37 +305,57 @@ class ScheduledTasksManager {
     }
   }
 
-  // Schedule a task
-  scheduleTask(task) {
+  // Execute scheduled tasks (called by MongoDB Atlas Scheduled Trigger)
+  async executeScheduledTasks(projectId) {
     try {
-      // Unschedule if already scheduled
-      this.unscheduleTask(task.id);
-
-      // Validate cron expression
-      if (!cron.validate(task.cronExpression)) {
-        console.error(`❌ Invalid cron expression for task ${task.id}: ${task.cronExpression}`);
-        return;
+      const db = await getDb();
+      const query = {
+        projectId: projectId,
+        isActive: true,
+        nextRun: {
+          $lte: new Date()
+        } // Only tasks where nextRun <= current time
+      };
+      const tasks = await db.collection("tasks").find(query).toArray();
+      for (const task of tasks) {
+        try {
+          console.log(`⏰ Executing: ${task.name} (${task.id}) for project ${task.projectId}`);
+
+          // Execute the task directly (we already have the task data)
+          const result = await this.executeTaskAction(task);
+
+          // Handle task completion and next run time in single update
+          const updateData = {};
+          if (!task.scheduledFor || this.isTimestamp(task.scheduledFor)) {
+            // For immediate and one-time tasks, deactivate after execution
+            updateData.isActive = false;
+            console.log(`✅ Task ${task.id} completed and deactivated`);
+          } else if (this.isCronExpression(task.scheduledFor)) {
+            // For recurring tasks, calculate next run time
+            updateData.nextRun = this.getNextRunTime(task.scheduledFor);
+            console.log(`📅 Updated next run time for task ${task.id}: ${updateData.nextRun}`);
+          }
+          await db.collection("tasks").updateOne({
+            id: task.id
+          }, {
+            $set: updateData
+          });
+          console.log(`✅ Task ${task.id} completed:`, result.success ? 'SUCCESS' : 'FAILED');
+        } catch (error) {
+          console.error(`❌ Task ${task.id} failed:`, error.message);
+        }
       }
-
-      // Schedule the task
-      const job = cron.schedule(task.cronExpression, async () => {
-        console.log(`⏰ Executing scheduled task: ${task.name} (${task.id})`);
-        await this.executeTaskAction(task);
-      });
-      this.scheduledJobs.set(task.id, job);
-      console.log(`✅ Scheduled task: ${task.name} (${task.id})`);
+      return {
+        success: true,
+        tasksExecuted: tasks.length,
+        projectId: projectId
+      };
     } catch (error) {
-      console.error(`❌ Failed to schedule task ${task.id}:`, error);
-    }
-  }
-
-  // Unschedule a task
-  unscheduleTask(taskId) {
-    const job = this.scheduledJobs.get(taskId);
-    if (job) {
-      job.stop();
-      this.scheduledJobs.delete(taskId);
-      console.log(`🛑 Unscheduled task: ${taskId}`);
+      console.error("❌ Failed to execute scheduled tasks:", error);
+      return {
+        success: false,
+        error: error.message
+      };
     }
   }
 
@@ -394,7 +363,9 @@ class ScheduledTasksManager {
   async executeTaskAction(task) {
     try {
       // Import tools manager
-      const toolsManager = require('./tools');
+      const {
+        toolsManager
+      } = require('./index');
 
       // Execute the tool action
       const result = await toolsManager.executeToolAction(task.userId, task.toolId, task.actionId, task.params);
@@ -429,10 +400,28 @@ class ScheduledTasksManager {
     }
   }
 
-  // Helper methods
-  generateTaskId() {
-    return `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  // Check if a string is a valid timestamp
+  isTimestamp(value) {
+    try {
+      const date = new Date(value);
+      return !isNaN(date.getTime()) && value !== date.toISOString().slice(0, 10); // Not just a date
+    } catch (error) {
+      return false;
+    }
+  }
+
+  // Check if a string is a cron expression
+  isCronExpression(value) {
+    try {
+      const parser = require('cron-parser');
+      parser.parseExpression(value);
+      return true;
+    } catch (error) {
+      return false;
+    }
   }
+
+  // Get next run time for cron expression
   getNextRunTime(cronExpression) {
     try {
       const parser = require('cron-parser');
@@ -443,15 +432,6 @@ class ScheduledTasksManager {
       return null;
     }
   }
-
-  // Get statistics
-  getStats() {
-    return {
-      isInitialized: this.isInitialized,
-      activeJobs: this.scheduledJobs.size,
-      totalJobs: this.scheduledJobs.size
-    };
-  }
 }
 
 // Create and export singleton instance

package/dist/{services → managers}/tools.js

@@ -2,7 +2,7 @@
 
 const {
   getDb
-} = require("./mongo");
+} = require("../services/mongo");
 const crypto = require('crypto');
 const config = require('../config');
 class ToolsManager {

package/dist/middleware/projectId.js

@@ -11,7 +11,7 @@ const config = require('../config');
  */
 const injectProjectId = (options = {}) => {
   const isCentralService = options.isCentralService || false;
-  const excludePaths = options.excludePaths || ['/auth/login', '/auth/register', '/health'];
+  const excludePaths = options.excludePaths || ['/health'];
   return (req, res, next) => {
     try {
       // Skip validation for excluded paths

package/dist/routes/functions.js

@@ -2,7 +2,9 @@
 
 const express = require("express");
 const router = express.Router();
-const functionsManager = require("../services/functions");
+const {
+  functionsManager
+} = require("../managers");
 const {
   getDb
 } = require("../services/mongo");

package/dist/routes/index.js

@@ -7,9 +7,6 @@ const {
 const {
   verifyToken
 } = require('../middleware/jwtToken');
-const functionsManager = require('../services/functions');
-const toolsManager = require('../services/tools');
-const scheduledTasksManager = require('../services/scheduledTasks');
 
 // Import all route modules
 const commentsRoutes = require('./comments');
@@ -29,7 +26,7 @@ const profilesRoutes = require('./profiles');
 const chatRoutes = require('./chat');
 const feedsRoutes = require('./feeds');
 const toolsRoutes = require('./tools');
-const scheduledTasksRoutes = require('./scheduledTasks');
+const tasksRoutes = require('./tasks');
 
 // Synchronous router creation
 const createPowrRoutes = (options = {}) => {
@@ -54,30 +51,9 @@ const createPowrRoutes = (options = {}) => {
   router.use('/chat', verifyToken, chatRoutes);
   router.use('/feeds', verifyToken, feedsRoutes);
   router.use('/tools', verifyToken, toolsRoutes);
-  router.use('/scheduled-tasks', verifyToken, scheduledTasksRoutes);
+  router.use('/tasks', verifyToken, tasksRoutes);
   return router;
 };
-
-// Async Functions initialization function
-const initializeFunctions = async (options = {}) => {
-  // Initialize Functions manager with options
-  await functionsManager.initialize(options);
-};
-
-// Async Tools initialization function
-const initializeTools = async (options = {}) => {
-  // Initialize Tools manager with options
-  await toolsManager.initialize(options);
-};
-
-// Async Scheduled Tasks initialization function
-const initializeScheduledTasks = async (options = {}) => {
-  // Initialize Scheduled Tasks manager with options
-  await scheduledTasksManager.initialize(options);
-};
 module.exports = {
-  createPowrRoutes,
-  initializeFunctions,
-  initializeTools,
-  initializeScheduledTasks
+  createPowrRoutes
 };