powr-sdk-api 4.1.8 → 4.1.10

package/dist/index.js

@@ -16,7 +16,8 @@ const {
 const {
   createPowrRoutes,
   initializeFunctions,
-  initializeTools
+  initializeTools,
+  initializeScheduledTasks
 } = require("./routes");
 const {
   verifyToken
@@ -30,5 +31,6 @@ module.exports = {
   createPowrRoutes,
   initializeFunctions,
   initializeTools,
+  initializeScheduledTasks,
   verifyToken
 };

package/dist/routes/index.js

@@ -9,6 +9,7 @@ const {
 } = 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');
@@ -28,6 +29,7 @@ const profilesRoutes = require('./profiles');
 const chatRoutes = require('./chat');
 const feedsRoutes = require('./feeds');
 const toolsRoutes = require('./tools');
+const scheduledTasksRoutes = require('./scheduledTasks');
 
 // Synchronous router creation
 const createPowrRoutes = (options = {}) => {
@@ -52,6 +54,7 @@ const createPowrRoutes = (options = {}) => {
   router.use('/chat', verifyToken, chatRoutes);
   router.use('/feeds', verifyToken, feedsRoutes);
   router.use('/tools', verifyToken, toolsRoutes);
+  router.use('/scheduled-tasks', verifyToken, scheduledTasksRoutes);
   return router;
 };
 
@@ -66,8 +69,15 @@ 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
+  initializeTools,
+  initializeScheduledTasks
 };

package/dist/routes/scheduledTasks.js

@@ -0,0 +1,240 @@
+"use strict";
+
+const express = require('express');
+const router = express.Router();
+const scheduledTasksManager = require('../services/scheduledTasks');
+const toolsManager = require('../services/tools');
+
+// GET /scheduled-tasks - Get all tasks for user
+router.get('/', async (req, res) => {
+  try {
+    const isAdmin = req.user.role === 'admin';
+    const result = await scheduledTasksManager.getUserTasks(req.user.powrId, req.projectId, isAdmin);
+    res.json(result);
+  } catch (error) {
+    console.error('❌ Error getting scheduled tasks:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to get scheduled tasks'
+    });
+  }
+});
+
+// GET /scheduled-tasks/:taskId - Get specific task
+router.get('/:taskId', async (req, res) => {
+  try {
+    const isAdmin = req.user.role === 'admin';
+    const result = await scheduledTasksManager.getTask(req.params.taskId, req.user.powrId, req.projectId, isAdmin);
+    if (!result.success) {
+      return res.status(404).json(result);
+    }
+    res.json(result);
+  } catch (error) {
+    console.error('❌ Error getting scheduled task:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to get scheduled task'
+    });
+  }
+});
+
+// POST /scheduled-tasks - Create new task
+router.post('/', async (req, res) => {
+  try {
+    var _tool$actions;
+    const {
+      name,
+      description,
+      cronExpression,
+      toolId,
+      actionId,
+      params,
+      isActive
+    } = req.body;
+
+    // Validate required fields
+    if (!name || !cronExpression || !toolId || !actionId) {
+      return res.status(400).json({
+        success: false,
+        message: 'Missing required fields: name, cronExpression, toolId, actionId'
+      });
+    }
+
+    // Validate tool exists
+    const tool = toolsManager.getTool(toolId);
+    if (!tool) {
+      return res.status(400).json({
+        success: false,
+        message: `Tool not found: ${toolId}`
+      });
+    }
+
+    // Validate action exists
+    const action = (_tool$actions = tool.actions) === null || _tool$actions === void 0 ? void 0 : _tool$actions.find(a => a.id === actionId);
+    if (!action) {
+      return res.status(400).json({
+        success: false,
+        message: `Action not found: ${actionId} for tool ${toolId}`
+      });
+    }
+    const taskData = {
+      name,
+      description,
+      cronExpression,
+      toolId,
+      actionId,
+      params: params || {},
+      userId: req.user.powrId,
+      projectId: req.projectId,
+      // Add projectId
+      isActive: isActive !== false // Default to true
+    };
+    const result = await scheduledTasksManager.createTask(taskData);
+    res.status(201).json(result);
+  } catch (error) {
+    console.error('❌ Error creating scheduled task:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to create scheduled task'
+    });
+  }
+});
+
+// PUT /scheduled-tasks/:taskId - Update task
+router.put('/:taskId', async (req, res) => {
+  try {
+    const {
+      name,
+      description,
+      cronExpression,
+      toolId,
+      actionId,
+      params,
+      isActive
+    } = req.body;
+
+    // Validate tool exists if toolId is being updated
+    if (toolId) {
+      const tool = toolsManager.getTool(toolId);
+      if (!tool) {
+        return res.status(400).json({
+          success: false,
+          message: `Tool not found: ${toolId}`
+        });
+      }
+
+      // Validate action exists if actionId is being updated
+      if (actionId) {
+        var _tool$actions2;
+        const action = (_tool$actions2 = tool.actions) === null || _tool$actions2 === void 0 ? void 0 : _tool$actions2.find(a => a.id === actionId);
+        if (!action) {
+          return res.status(400).json({
+            success: false,
+            message: `Action not found: ${actionId} for tool ${toolId}`
+          });
+        }
+      }
+    }
+    const updates = {};
+    if (name !== undefined) updates.name = name;
+    if (description !== undefined) updates.description = description;
+    if (cronExpression !== undefined) updates.cronExpression = cronExpression;
+    if (toolId !== undefined) updates.toolId = toolId;
+    if (actionId !== undefined) updates.actionId = actionId;
+    if (params !== undefined) updates.params = params;
+    if (isActive !== undefined) updates.isActive = isActive;
+    const isAdmin = req.user.role === 'admin';
+    const result = await scheduledTasksManager.updateTask(req.params.taskId, req.user.powrId, req.projectId, updates, isAdmin);
+    if (!result.success) {
+      return res.status(404).json(result);
+    }
+    res.json(result);
+  } catch (error) {
+    console.error('❌ Error updating scheduled task:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to update scheduled task'
+    });
+  }
+});
+
+// DELETE /scheduled-tasks/:taskId - Delete task
+router.delete('/:taskId', async (req, res) => {
+  try {
+    const isAdmin = req.user.role === 'admin';
+    const result = await scheduledTasksManager.deleteTask(req.params.taskId, req.user.powrId, req.projectId, isAdmin);
+    if (!result.success) {
+      return res.status(404).json(result);
+    }
+    res.json(result);
+  } catch (error) {
+    console.error('❌ Error deleting scheduled task:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to delete scheduled task'
+    });
+  }
+});
+
+// POST /scheduled-tasks/:taskId/toggle - Toggle task active status
+router.post('/:taskId/toggle', async (req, res) => {
+  try {
+    const {
+      isActive
+    } = req.body;
+    if (typeof isActive !== 'boolean') {
+      return res.status(400).json({
+        success: false,
+        message: 'isActive must be a boolean value'
+      });
+    }
+    const isAdmin = req.user.role === 'admin';
+    const result = await scheduledTasksManager.toggleTask(req.params.taskId, req.user.powrId, req.projectId, isActive, isAdmin);
+    if (!result.success) {
+      return res.status(404).json(result);
+    }
+    res.json(result);
+  } catch (error) {
+    console.error('❌ Error toggling scheduled task:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to toggle scheduled task'
+    });
+  }
+});
+
+// POST /scheduled-tasks/:taskId/execute - Execute task manually
+router.post('/:taskId/execute', async (req, res) => {
+  try {
+    const isAdmin = req.user.role === 'admin';
+    const result = await scheduledTasksManager.executeTask(req.params.taskId, req.user.powrId, req.projectId, isAdmin);
+    if (!result.success) {
+      return res.status(404).json(result);
+    }
+    res.json(result);
+  } catch (error) {
+    console.error('❌ Error executing scheduled task:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to execute scheduled task'
+    });
+  }
+});
+
+// GET /scheduled-tasks/stats - Get scheduler statistics
+router.get('/stats', async (req, res) => {
+  try {
+    const stats = scheduledTasksManager.getStats();
+    res.json({
+      success: true,
+      stats
+    });
+  } catch (error) {
+    console.error('❌ Error getting scheduler stats:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to get scheduler stats'
+    });
+  }
+});
+module.exports = router;

package/dist/services/scheduledTasks.js

@@ -0,0 +1,459 @@
+"use strict";
+
+const {
+  getDb
+} = require("./mongo");
+const cron = require('node-cron');
+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),
+        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);
+      }
+      console.log(`✅ Created scheduled task: ${task.name} (${task.id})`);
+      return {
+        success: true,
+        task
+      };
+    } catch (error) {
+      console.error("❌ Failed to create scheduled task:", error);
+      return {
+        success: false,
+        message: error.message
+      };
+    }
+  }
+
+  // Get all tasks for a user (filtered by projectId and userId)
+  async getUserTasks(userId, projectId, isAdmin = false) {
+    try {
+      const db = await getDb();
+
+      // Build query based on user role
+      let query = {};
+      if (isAdmin) {
+        // Admin sees all tasks in the project
+        query.projectId = projectId;
+      } else {
+        // Regular users see only their tasks in the project
+        query.userId = userId;
+        query.projectId = projectId;
+      }
+      const tasks = await db.collection("scheduled_tasks").find(query).sort({
+        createdAt: -1
+      }).toArray();
+      return {
+        success: true,
+        tasks
+      };
+    } catch (error) {
+      console.error("❌ Failed to get user tasks:", error);
+      return {
+        success: false,
+        message: error.message
+      };
+    }
+  }
+
+  // Get a specific task (with project and user validation)
+  async getTask(taskId, userId, projectId, isAdmin = false) {
+    try {
+      const db = await getDb();
+
+      // Build query based on user role
+      let query = {
+        id: taskId
+      };
+      if (isAdmin) {
+        // Admin can access any task in the project
+        query.projectId = projectId;
+      } else {
+        // Regular users can only access their own tasks
+        query.userId = userId;
+        query.projectId = projectId;
+      }
+      const task = await db.collection("scheduled_tasks").findOne(query);
+      if (!task) {
+        return {
+          success: false,
+          message: "Task not found"
+        };
+      }
+      return {
+        success: true,
+        task
+      };
+    } catch (error) {
+      console.error("❌ Failed to get task:", error);
+      return {
+        success: false,
+        message: error.message
+      };
+    }
+  }
+
+  // Update a task (with project and user validation)
+  async updateTask(taskId, userId, projectId, updates, isAdmin = false) {
+    try {
+      const db = await getDb();
+
+      // Build query based on user role
+      let query = {
+        id: taskId
+      };
+      if (isAdmin) {
+        // Admin can update any task in the project
+        query.projectId = projectId;
+      } else {
+        // Regular users can only update their own tasks
+        query.userId = userId;
+        query.projectId = projectId;
+      }
+
+      // Get existing task
+      const existingTask = await db.collection("scheduled_tasks").findOne(query);
+      if (!existingTask) {
+        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
+      });
+
+      // Reschedule if active
+      if (updatedTask.isActive) {
+        this.unscheduleTask(taskId);
+        this.scheduleTask(updatedTask);
+      } else {
+        this.unscheduleTask(taskId);
+      }
+      console.log(`✅ Updated scheduled task: ${updatedTask.name} (${taskId})`);
+      return {
+        success: true,
+        task: updatedTask
+      };
+    } catch (error) {
+      console.error("❌ Failed to update scheduled task:", error);
+      return {
+        success: false,
+        message: error.message
+      };
+    }
+  }
+
+  // Delete a task (with project and user validation)
+  async deleteTask(taskId, userId, projectId, isAdmin = false) {
+    try {
+      const db = await getDb();
+
+      // Build query based on user role
+      let query = {
+        id: taskId
+      };
+      if (isAdmin) {
+        // Admin can delete any task in the project
+        query.projectId = projectId;
+      } else {
+        // Regular users can only delete their own tasks
+        query.userId = userId;
+        query.projectId = projectId;
+      }
+
+      // Get task to check if it exists
+      const task = await db.collection("scheduled_tasks").findOne(query);
+      if (!task) {
+        return {
+          success: false,
+          message: "Task not found"
+        };
+      }
+
+      // Remove from database
+      await db.collection("scheduled_tasks").deleteOne(query);
+
+      // Unschedule the task
+      this.unscheduleTask(taskId);
+      console.log(`✅ Deleted scheduled task: ${task.name} (${taskId})`);
+      return {
+        success: true
+      };
+    } catch (error) {
+      console.error("❌ Failed to delete scheduled task:", error);
+      return {
+        success: false,
+        message: error.message
+      };
+    }
+  }
+
+  // Toggle task active status (with project and user validation)
+  async toggleTask(taskId, userId, projectId, isActive, isAdmin = false) {
+    try {
+      const db = await getDb();
+
+      // Build query based on user role
+      let query = {
+        id: taskId
+      };
+      if (isAdmin) {
+        // Admin can toggle any task in the project
+        query.projectId = projectId;
+      } else {
+        // Regular users can only toggle their own tasks
+        query.userId = userId;
+        query.projectId = projectId;
+      }
+      const task = await db.collection("scheduled_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);
+      }
+      console.log(`${isActive ? '✅' : '❌'} Task ${taskId} ${isActive ? 'activated' : 'deactivated'}`);
+      return {
+        success: true
+      };
+    } catch (error) {
+      console.error("❌ Failed to toggle task:", error);
+      return {
+        success: false,
+        message: error.message
+      };
+    }
+  }
+
+  // Execute a task manually (with project and user validation)
+  async executeTask(taskId, userId, projectId, isAdmin = false) {
+    try {
+      const db = await getDb();
+
+      // Build query based on user role
+      let query = {
+        id: taskId
+      };
+      if (isAdmin) {
+        // Admin can execute any task in the project
+        query.projectId = projectId;
+      } else {
+        // Regular users can only execute their own tasks
+        query.userId = userId;
+        query.projectId = projectId;
+      }
+      const task = await db.collection("scheduled_tasks").findOne(query);
+      if (!task) {
+        return {
+          success: false,
+          message: "Task not found"
+        };
+      }
+      console.log(`🚀 Manually executing task: ${task.name} (${taskId})`);
+
+      // 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
+      };
+    } catch (error) {
+      console.error("❌ Failed to execute task:", error);
+      return {
+        success: false,
+        message: error.message
+      };
+    }
+  }
+
+  // Schedule a task
+  scheduleTask(task) {
+    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;
+      }
+
+      // 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})`);
+    } 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}`);
+    }
+  }
+
+  // Execute the actual task action
+  async executeTaskAction(task) {
+    try {
+      // Import tools manager
+      const toolsManager = require('./tools');
+
+      // Execute the tool action
+      const result = await toolsManager.executeToolAction(task.userId, task.toolId, task.actionId, task.params);
+
+      // Log execution
+      await this.logTaskExecution(task, result);
+      return result;
+    } catch (error) {
+      console.error(`❌ Task execution failed for ${task.id}:`, error);
+      return {
+        success: false,
+        message: error.message
+      };
+    }
+  }
+
+  // Log task execution
+  async logTaskExecution(task, result) {
+    try {
+      const db = await getDb();
+      await db.collection("task_executions").insertOne({
+        taskId: task.id,
+        userId: task.userId,
+        toolId: task.toolId,
+        actionId: task.actionId,
+        params: task.params,
+        result: result,
+        executedAt: new Date()
+      });
+    } catch (error) {
+      console.error("❌ Failed to log task execution:", error);
+    }
+  }
+
+  // Helper methods
+  generateTaskId() {
+    return `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+  getNextRunTime(cronExpression) {
+    try {
+      const parser = require('cron-parser');
+      const interval = parser.parseExpression(cronExpression);
+      return interval.next().toDate();
+    } catch (error) {
+      console.error("❌ Failed to parse cron expression:", error);
+      return null;
+    }
+  }
+
+  // Get statistics
+  getStats() {
+    return {
+      isInitialized: this.isInitialized,
+      activeJobs: this.scheduledJobs.size,
+      totalJobs: this.scheduledJobs.size
+    };
+  }
+}
+
+// Create and export singleton instance
+const scheduledTasksManager = new ScheduledTasksManager();
+module.exports = scheduledTasksManager;

package/dist/services/tools.js

@@ -301,6 +301,9 @@ class ToolsManager {
       switch (tool.name.toLowerCase()) {
         case 'gmail':
           return await this.executeGmailAction(actionId, params, config);
+        case 'weather':
+        case 'openweather':
+          return await this.executeWeatherAction(actionId, params, config, tool);
         case 'slack':
           return await this.executeSlackAction(actionId, params, config);
         case 'github':
@@ -364,6 +367,65 @@ class ToolsManager {
       };
     }
   }
+  async executeWeatherAction(actionId, params, config, tool) {
+    const axios = require('axios');
+    try {
+      var _tool$systemConfig;
+      // Get weather data from system config (database) or fallback to env var
+      const weatherApiKey = (tool === null || tool === void 0 || (_tool$systemConfig = tool.systemConfig) === null || _tool$systemConfig === void 0 ? void 0 : _tool$systemConfig.apiKey) || process.env.WEATHER_API_KEY || 'demo';
+      const location = config.location;
+      let weatherData;
+      if (weatherApiKey === 'demo') {
+        // Demo weather data for testing
+        weatherData = {
+          weather: [{
+            main: params.condition || 'Rain',
+            description: 'light rain'
+          }]
+        };
+        console.log('🌤️ Using demo weather data');
+      } else {
+        // Real weather API call
+        const weatherResponse = await axios.get(`https://api.openweathermap.org/data/2.5/weather?q=${encodeURIComponent(location)}&appid=${weatherApiKey}&units=metric`);
+        weatherData = weatherResponse.data;
+      }
+
+      // Check if condition matches
+      const currentWeather = weatherData.weather[0].main.toLowerCase();
+      const targetCondition = params.condition.toLowerCase();
+      const operator = params.operator || 'is';
+      let conditionMet = false;
+      switch (operator) {
+        case 'is':
+          conditionMet = currentWeather === targetCondition;
+          break;
+        case 'is_not':
+          conditionMet = currentWeather !== targetCondition;
+          break;
+        case 'contains':
+          conditionMet = currentWeather.includes(targetCondition) || weatherData.weather[0].description.toLowerCase().includes(targetCondition);
+          break;
+        default:
+          conditionMet = currentWeather === targetCondition;
+      }
+      return {
+        success: true,
+        message: `Weather check completed. Current: ${currentWeather}, Required: ${targetCondition}`,
+        data: {
+          currentWeather: currentWeather,
+          requiredCondition: targetCondition,
+          conditionMet: conditionMet,
+          location: location
+        }
+      };
+    } catch (error) {
+      console.error('❌ Weather check error:', error);
+      return {
+        success: false,
+        message: `Failed to check weather: ${error.message}`
+      };
+    }
+  }
   async executeSlackAction(actionId, params, config) {
     // TODO: Implement Slack actions
     return {

package/package.json

@@ -1,68 +1,71 @@
-{
-  "name": "powr-sdk-api",
-  "version": "4.1.8",
-  "description": "Shared API core library for PowrStack projects",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "scripts": {
-    "test": "jest --passWithNoTests",
-    "lint": "eslint .",
-    "build": "babel src -d dist",
-    "prepare": "npm run build",
-    "prepublishOnly": "npm run test"
-  },
-  "keywords": [
-    "api",
-    "express",
-    "middleware",
-    "error-handling",
-    "response-formatting",
-    "logging",
-    "swagger",
-    "documentation"
-  ],
-  "author": "Lawazia Tech",
-  "license": "ISC",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/powrstack/powr-sdk-api.git"
-  },
-  "bugs": {
-    "url": "https://github.com/powrstack/powr-sdk-api/issues"
-  },
-  "homepage": "https://github.com/powrstack/powr-sdk-api#readme",
-  "dependencies": {
-    "@aws-sdk/client-s3": "^3.787.0",
-    "@google-cloud/storage": "^7.16.0",
-    "express": "^4.18.2",
-    "jsonwebtoken": "^9.0.2",
-    "swagger-jsdoc": "^6.2.8",
-    "swagger-ui-express": "^5.0.0",
-    "winston": "^3.17.0",
-    "mongodb": "^6.3.0",
-    "multer": "^1.4.5-lts.1",
-    "bcrypt": "^5.1.1",
-    "nodemailer": "^6.10.0"
-  },
-  "devDependencies": {
-    "@babel/cli": "^7.23.9",
-    "@babel/core": "^7.24.0",
-    "@babel/preset-env": "^7.24.0",
-    "@types/express": "^4.17.21",
-    "@types/swagger-jsdoc": "^6.0.4",
-    "@types/swagger-ui-express": "^4.1.6",
-    "eslint": "^8.57.0",
-    "jest": "^29.7.0",
-    "typescript": "^5.3.3"
-  },
-  "peerDependencies": {
-    "express": "^4.18.2"
-  },
-  "engines": {
-    "node": ">=14.0.0"
-  }
-}
+{
+  "name": "powr-sdk-api",
+  "version": "4.1.10",
+  "description": "Shared API core library for PowrStack projects",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "jest --passWithNoTests",
+    "lint": "eslint .",
+    "build": "babel src -d dist",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run test"
+  },
+  "keywords": [
+    "api",
+    "express",
+    "middleware",
+    "error-handling",
+    "response-formatting",
+    "logging",
+    "swagger",
+    "documentation"
+  ],
+  "author": "Lawazia Tech",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/powrstack/powr-sdk-api.git"
+  },
+  "bugs": {
+    "url": "https://github.com/powrstack/powr-sdk-api/issues"
+  },
+  "homepage": "https://github.com/powrstack/powr-sdk-api#readme",
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.787.0",
+    "@google-cloud/storage": "^7.16.0",
+    "axios": "^1.6.0",
+    "bcrypt": "^5.1.1",
+    "cron-parser": "^4.9.0",
+    "express": "^4.18.2",
+    "jsonwebtoken": "^9.0.2",
+    "mongodb": "^6.3.0",
+    "multer": "^1.4.5-lts.1",
+    "node-cron": "^3.0.3",
+    "nodemailer": "^6.10.0",
+    "swagger-jsdoc": "^6.2.8",
+    "swagger-ui-express": "^5.0.0",
+    "winston": "^3.17.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.23.9",
+    "@babel/core": "^7.24.0",
+    "@babel/preset-env": "^7.24.0",
+    "@types/express": "^4.17.21",
+    "@types/swagger-jsdoc": "^6.0.4",
+    "@types/swagger-ui-express": "^4.1.6",
+    "eslint": "^8.57.0",
+    "jest": "^29.7.0",
+    "typescript": "^5.3.3"
+  },
+  "peerDependencies": {
+    "express": "^4.18.2"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}