powr-sdk-api 4.2.0 → 4.3.0

package/dist/middleware/auth.js

@@ -1,76 +0,0 @@
-"use strict";
-
-const jwt = require("jsonwebtoken");
-const generateToken = user => {
-  return jwt.sign({
-    userId: user.userId
-  }, process.env.JWT_SECRET, {
-    expiresIn: process.env.JWT_EXPIRES_IN || '24h'
-  });
-};
-const validateToken = async (req, res, next) => {
-  try {
-    let token;
-
-    // Check if token exists in headers
-    if (req.headers.authorization && req.headers.authorization.startsWith("Bearer")) {
-      token = req.headers.authorization.split(" ")[1];
-    }
-    if (!token) {
-      return res.error("Not authorized to access this route", 401);
-    }
-    try {
-      // Verify token
-      const decoded = jwt.verify(token, process.env.JWT_SECRET);
-
-      // // Get user from token
-      // const user = await User.findByPk(decoded.userId);
-      // if (!user) {
-      //     return res.error('User not found', 401);
-      // }
-
-      // // Add user and userId to request object
-      // req.user = user;
-      req.userId = decoded.userId;
-      next();
-    } catch (error) {
-      return res.error("Not authorized to access this route", 401, error);
-    }
-  } catch (error) {
-    return res.error("Error authenticating user", 500, error);
-  }
-};
-const validateAuth = (options = {}) => {
-  const {
-    publicPaths = ["/auth", "/", "/status", "/swagger"],
-    publicMethods = ["OPTIONS"]
-  } = options;
-  return async (req, res, next) => {
-    // Skip auth validation for public paths
-    if (publicPaths.some(path => req.path.startsWith(path))) {
-      return next();
-    }
-
-    // Skip auth validation for public methods
-    if (publicMethods.includes(req.method)) {
-      return next();
-    }
-
-    // Use the original validateToken middleware for protected routes
-    return validateToken(req, res, next);
-  };
-};
-
-// exports.authorize = (...roles) => {
-//     return (req, res, next) => {
-//         if (!roles.includes(req.user.role)) {
-//             return res.error(`User role ${req.user.role} is not authorized to access this route`, 403);
-//         }
-//         next();
-//     };
-// };
-
-module.exports = {
-  validateAuth,
-  generateToken
-};

package/dist/middleware/logger.js

@@ -1,45 +0,0 @@
-"use strict";
-
-/**
- * Logging middleware for Express applications
- */
-
-const logger = (req, res, next) => {
-  const startTime = Date.now();
-
-  // Log request with redacted sensitive information
-  try {
-    const logBody = {
-      ...req.body
-    };
-    if (logBody.password) logBody.password = "[REDACTED]";
-    if (logBody.token) logBody.token = "[REDACTED]";
-    console.log('Request:', {
-      timestamp: new Date().toISOString(),
-      method: req.method,
-      url: req.originalUrl,
-      ip: req.ip,
-      userAgent: req.get('user-agent'),
-      body: logBody,
-      query: req.query
-    });
-  } catch (error) {
-    console.error("Error logging request:", error);
-  }
-
-  // Log response with timing information
-  res.on('finish', () => {
-    const responseTime = Date.now() - startTime;
-    console.log('Response:', {
-      timestamp: new Date().toISOString(),
-      method: req.method,
-      url: req.originalUrl,
-      statusCode: res.statusCode,
-      responseTime: `${responseTime}ms`,
-      userAgent: req.get('user-agent'),
-      ip: req.ip
-    });
-  });
-  next();
-};
-module.exports = logger;

package/dist/middleware/response.js

@@ -1,53 +0,0 @@
-"use strict";
-
-const logger = require('../services/logger');
-const responseFormatter = (req, res, next) => {
-  // Add success method to response object
-  res.success = function (message = 'Success', statusCode = 200, data = null) {
-    const response = {
-      success: true,
-      message
-    };
-
-    // Only include data if it's not null
-    if (data !== null) {
-      response.data = data;
-    }
-    return this.status(statusCode).json(response);
-  };
-
-  // Add error method to response object
-  res.error = function (message = 'Error', statusCode = 500, error = null) {
-    const response = {
-      success: false,
-      message
-    };
-
-    // Only include details if they're not null
-    if (error !== null) {
-      response.error = error;
-    }
-    return this.status(statusCode).json(response);
-  };
-  next();
-};
-const responseLogger = (req, res, next) => {
-  const startTime = Date.now();
-  res.on('finish', () => {
-    const responseTime = Date.now() - startTime;
-    logger.info('API Response', {
-      method: req.method,
-      url: req.originalUrl,
-      statusCode: res.statusCode,
-      responseTime: `${responseTime}ms`,
-      userAgent: req.get('user-agent'),
-      ip: req.ip,
-      response: res.locals.responseBody || '[not captured]'
-    });
-  });
-  next();
-};
-module.exports = {
-  responseFormatter,
-  responseLogger
-};

package/dist/routes/admin/index.js

@@ -1,520 +0,0 @@
-"use strict";
-
-// Admin routes for powr-sdk-api
-// This file contains the admin route handlers for common admin operations
-
-const {
-  MongoClient
-} = require('mongodb');
-const createAdminRoutes = (app, options = {}) => {
-  const {
-    projectId,
-    apiUrl = '/admin',
-    authMiddleware = null,
-    logger = console,
-    mongoUrl = process.env.MONGODB_URI || 'mongodb://localhost:27017/powrbase'
-  } = options;
-  let db;
-
-  // Connect to MongoDB
-  const connectDB = async () => {
-    try {
-      const client = new MongoClient(mongoUrl);
-      await client.connect();
-      db = client.db();
-      logger.info('Connected to MongoDB');
-    } catch (error) {
-      logger.error('MongoDB connection error:', error);
-    }
-  };
-
-  // Initialize database connection
-  connectDB();
-
-  // Forms Admin Routes
-  app.get(`${apiUrl}/forms`, async (req, res) => {
-    try {
-      const forms = await db.collection('forms').find({
-        projectId
-      }).toArray();
-      res.json({
-        success: true,
-        forms
-      });
-    } catch (error) {
-      logger.error('Error fetching forms:', error);
-      res.status(500).json({
-        success: false,
-        error: 'Failed to fetch forms'
-      });
-    }
-  });
-  app.post(`${apiUrl}/forms`, async (req, res) => {
-    try {
-      const {
-        name,
-        fields,
-        settings
-      } = req.body;
-      const form = {
-        projectId,
-        name,
-        fields,
-        settings,
-        createdAt: new Date(),
-        updatedAt: new Date()
-      };
-      const result = await db.collection('forms').insertOne(form);
-      res.json({
-        success: true,
-        form: {
-          ...form,
-          _id: result.insertedId
-        }
-      });
-    } catch (error) {
-      logger.error('Error creating form:', error);
-      res.status(500).json({
-        success: false,
-        error: 'Failed to create form'
-      });
-    }
-  });
-  app.put(`${apiUrl}/forms/:id`, async (req, res) => {
-    try {
-      const {
-        id
-      } = req.params;
-      const {
-        name,
-        fields,
-        settings
-      } = req.body;
-      const result = await db.collection('forms').updateOne({
-        _id: id,
-        projectId
-      }, {
-        $set: {
-          name,
-          fields,
-          settings,
-          updatedAt: new Date()
-        }
-      });
-      if (result.matchedCount === 0) {
-        return res.status(404).json({
-          success: false,
-          error: 'Form not found'
-        });
-      }
-      res.json({
-        success: true,
-        message: 'Form updated successfully'
-      });
-    } catch (error) {
-      logger.error('Error updating form:', error);
-      res.status(500).json({
-        success: false,
-        error: 'Failed to update form'
-      });
-    }
-  });
-  app.delete(`${apiUrl}/forms/:id`, async (req, res) => {
-    try {
-      const {
-        id
-      } = req.params;
-      const result = await db.collection('forms').deleteOne({
-        _id: id,
-        projectId
-      });
-      if (result.deletedCount === 0) {
-        return res.status(404).json({
-          success: false,
-          error: 'Form not found'
-        });
-      }
-      res.json({
-        success: true,
-        message: 'Form deleted successfully'
-      });
-    } catch (error) {
-      logger.error('Error deleting form:', error);
-      res.status(500).json({
-        success: false,
-        error: 'Failed to delete form'
-      });
-    }
-  });
-
-  // Waitlists Admin Routes
-  app.get(`${apiUrl}/waitlists`, async (req, res) => {
-    try {
-      const waitlists = await db.collection('waitlists').find({
-        projectId
-      }).toArray();
-      res.json({
-        success: true,
-        waitlists
-      });
-    } catch (error) {
-      logger.error('Error fetching waitlists:', error);
-      res.status(500).json({
-        success: false,
-        error: 'Failed to fetch waitlists'
-      });
-    }
-  });
-  app.post(`${apiUrl}/waitlists`, async (req, res) => {
-    try {
-      const {
-        email,
-        name,
-        phone,
-        additionalInfo
-      } = req.body;
-      const entry = {
-        projectId,
-        email,
-        name,
-        phone,
-        additionalInfo,
-        createdAt: new Date()
-      };
-      const result = await db.collection('waitlists').insertOne(entry);
-      res.json({
-        success: true,
-        entry: {
-          ...entry,
-          _id: result.insertedId
-        }
-      });
-    } catch (error) {
-      logger.error('Error adding waitlist entry:', error);
-      res.status(500).json({
-        success: false,
-        error: 'Failed to add entry'
-      });
-    }
-  });
-
-  // Slides Admin Routes
-  app.get(`${apiUrl}/slides`, async (req, res) => {
-    try {
-      const slides = await db.collection('slides').find({
-        projectId
-      }).toArray();
-      res.json({
-        success: true,
-        slides
-      });
-    } catch (error) {
-      logger.error('Error fetching slides:', error);
-      res.status(500).json({
-        success: false,
-        error: 'Failed to fetch slides'
-      });
-    }
-  });
-  app.post(`${apiUrl}/slides`, async (req, res) => {
-    try {
-      const {
-        title,
-        description,
-        imageUrl,
-        link,
-        order
-      } = req.body;
-      const slide = {
-        projectId,
-        title,
-        description,
-        imageUrl,
-        link,
-        order: order || 0,
-        createdAt: new Date(),
-        updatedAt: new Date()
-      };
-      const result = await db.collection('slides').insertOne(slide);
-      res.json({
-        success: true,
-        slide: {
-          ...slide,
-          _id: result.insertedId
-        }
-      });
-    } catch (error) {
-      logger.error('Error creating slide:', error);
-      res.status(500).json({
-        success: false,
-        error: 'Failed to create slide'
-      });
-    }
-  });
-  app.put(`${apiUrl}/slides/:id`, async (req, res) => {
-    try {
-      const {
-        id
-      } = req.params;
-      const {
-        title,
-        description,
-        imageUrl,
-        link,
-        order
-      } = req.body;
-      const result = await db.collection('slides').updateOne({
-        _id: id,
-        projectId
-      }, {
-        $set: {
-          title,
-          description,
-          imageUrl,
-          link,
-          order,
-          updatedAt: new Date()
-        }
-      });
-      if (result.matchedCount === 0) {
-        return res.status(404).json({
-          success: false,
-          error: 'Slide not found'
-        });
-      }
-      res.json({
-        success: true,
-        message: 'Slide updated successfully'
-      });
-    } catch (error) {
-      logger.error('Error updating slide:', error);
-      res.status(500).json({
-        success: false,
-        error: 'Failed to update slide'
-      });
-    }
-  });
-  app.delete(`${apiUrl}/slides/:id`, async (req, res) => {
-    try {
-      const {
-        id
-      } = req.params;
-      const result = await db.collection('slides').deleteOne({
-        _id: id,
-        projectId
-      });
-      if (result.deletedCount === 0) {
-        return res.status(404).json({
-          success: false,
-          error: 'Slide not found'
-        });
-      }
-      res.json({
-        success: true,
-        message: 'Slide deleted successfully'
-      });
-    } catch (error) {
-      logger.error('Error deleting slide:', error);
-      res.status(500).json({
-        success: false,
-        error: 'Failed to delete slide'
-      });
-    }
-  });
-
-  // Invoices Admin Routes
-  app.get(`${apiUrl}/invoices`, async (req, res) => {
-    try {
-      const invoices = await db.collection('invoices').find({
-        projectId
-      }).toArray();
-      res.json({
-        success: true,
-        invoices
-      });
-    } catch (error) {
-      logger.error('Error fetching invoices:', error);
-      res.status(500).json({
-        success: false,
-        error: 'Failed to fetch invoices'
-      });
-    }
-  });
-  app.post(`${apiUrl}/invoices`, async (req, res) => {
-    try {
-      const {
-        invoiceNumber,
-        clientName,
-        clientEmail,
-        amount,
-        description,
-        dueDate,
-        status = 'pending'
-      } = req.body;
-      const invoice = {
-        projectId,
-        invoiceNumber,
-        clientName,
-        clientEmail,
-        amount,
-        description,
-        dueDate: new Date(dueDate),
-        status,
-        createdAt: new Date(),
-        updatedAt: new Date()
-      };
-      const result = await db.collection('invoices').insertOne(invoice);
-      res.json({
-        success: true,
-        invoice: {
-          ...invoice,
-          _id: result.insertedId
-        }
-      });
-    } catch (error) {
-      logger.error('Error creating invoice:', error);
-      res.status(500).json({
-        success: false,
-        error: 'Failed to create invoice'
-      });
-    }
-  });
-  app.put(`${apiUrl}/invoices/:id`, async (req, res) => {
-    try {
-      const {
-        id
-      } = req.params;
-      const {
-        invoiceNumber,
-        clientName,
-        clientEmail,
-        amount,
-        description,
-        dueDate,
-        status
-      } = req.body;
-      const result = await db.collection('invoices').updateOne({
-        _id: id,
-        projectId
-      }, {
-        $set: {
-          invoiceNumber,
-          clientName,
-          clientEmail,
-          amount,
-          description,
-          dueDate: new Date(dueDate),
-          status,
-          updatedAt: new Date()
-        }
-      });
-      if (result.matchedCount === 0) {
-        return res.status(404).json({
-          success: false,
-          error: 'Invoice not found'
-        });
-      }
-      res.json({
-        success: true,
-        message: 'Invoice updated successfully'
-      });
-    } catch (error) {
-      logger.error('Error updating invoice:', error);
-      res.status(500).json({
-        success: false,
-        error: 'Failed to update invoice'
-      });
-    }
-  });
-
-  // Notifications Admin Routes
-  app.get(`${apiUrl}/notifications`, async (req, res) => {
-    try {
-      const notifications = await db.collection('notifications').find({
-        projectId
-      }).toArray();
-      res.json({
-        success: true,
-        notifications
-      });
-    } catch (error) {
-      logger.error('Error fetching notifications:', error);
-      res.status(500).json({
-        success: false,
-        error: 'Failed to fetch notifications'
-      });
-    }
-  });
-  app.post(`${apiUrl}/notifications`, async (req, res) => {
-    try {
-      const {
-        title,
-        message,
-        type = 'info',
-        priority = 'normal',
-        targetUsers = 'all'
-      } = req.body;
-      const notification = {
-        projectId,
-        title,
-        message,
-        type,
-        priority,
-        targetUsers,
-        isRead: false,
-        createdAt: new Date()
-      };
-      const result = await db.collection('notifications').insertOne(notification);
-      res.json({
-        success: true,
-        notification: {
-          ...notification,
-          _id: result.insertedId
-        }
-      });
-    } catch (error) {
-      logger.error('Error creating notification:', error);
-      res.status(500).json({
-        success: false,
-        error: 'Failed to create notification'
-      });
-    }
-  });
-  app.put(`${apiUrl}/notifications/:id/read`, async (req, res) => {
-    try {
-      const {
-        id
-      } = req.params;
-      const result = await db.collection('notifications').updateOne({
-        _id: id,
-        projectId
-      }, {
-        $set: {
-          isRead: true,
-          updatedAt: new Date()
-        }
-      });
-      if (result.matchedCount === 0) {
-        return res.status(404).json({
-          success: false,
-          error: 'Notification not found'
-        });
-      }
-      res.json({
-        success: true,
-        message: 'Notification marked as read'
-      });
-    } catch (error) {
-      logger.error('Error updating notification:', error);
-      res.status(500).json({
-        success: false,
-        error: 'Failed to update notification'
-      });
-    }
-  });
-  logger.info('Admin routes initialized for project:', projectId);
-  return app;
-};
-module.exports = {
-  createAdminRoutes
-};