powr-sdk-api 1.5.2 → 2.0.2

package/README.md

@@ -0,0 +1,109 @@
+# Powr SDK API
+
+A shared API core library for PowrStack projects that provides common middleware, error handling, logging, and route management.
+
+## Installation
+
+```bash
+npm install powr-sdk-api
+```
+
+## Usage
+
+### Basic Setup
+
+```javascript
+const express = require('express');
+const { 
+  createRoutes, 
+  errorHandler, 
+  requestHandler, 
+  logger 
+} = require('powr-sdk-api');
+
+const app = express();
+
+// Add middleware
+app.use(requestHandler);
+app.use(express.json());
+
+// Initialize routes
+createRoutes(app, {
+  projectId: 'your-project-id',
+  baseUrl: '/api',
+  logger: logger
+});
+
+// Error handling (should be last)
+app.use(errorHandler);
+
+app.listen(3000, () => {
+  logger.info('Server running on port 3000');
+});
+```
+
+### Admin Routes Only
+
+```javascript
+const express = require('express');
+const { createAdminRoutes } = require('powr-sdk-api');
+
+const app = express();
+
+// Initialize only admin routes
+createAdminRoutes(app, {
+  projectId: 'your-project-id',
+  apiUrl: '/admin',
+  logger: console
+});
+
+app.listen(3000);
+```
+
+### With Custom Middleware
+
+```javascript
+const express = require('express');
+const { createRoutes, validateAuth } = require('powr-sdk-api');
+
+const app = express();
+
+// Custom auth middleware
+const customAuth = (req, res, next) => {
+  // Your custom authentication logic
+  next();
+};
+
+createRoutes(app, {
+  projectId: 'your-project-id',
+  authMiddleware: customAuth,
+  logger: console
+});
+
+app.listen(3000);
+```
+
+## Available Exports
+
+- `createRoutes(app, options)` - Initialize all routes
+- `createAdminRoutes(app, options)` - Initialize only admin routes
+- `errorHandler` - Express error handling middleware
+- `requestHandler` - Request logging middleware
+- `validateAuth` - JWT authentication middleware
+- `generateToken` - JWT token generation utility
+- `logger` - Winston logger instance
+- `createSwaggerSpec` - Swagger documentation generator
+
+## Options
+
+### createRoutes/createAdminRoutes options:
+
+- `projectId` (required) - Your project identifier
+- `baseUrl` (optional) - Base URL for routes (default: '/api')
+- `apiUrl` (optional) - Admin API URL (default: '/admin')
+- `authMiddleware` (optional) - Custom authentication middleware
+- `logger` (optional) - Logger instance (default: console)
+
+## Version
+
+Current version: 2.0.1 

package/dist/index.js

@@ -16,6 +16,11 @@ const {
 } = require("./middleware/notfound");
 const createSwaggerSpec = require("./swagger");
 const logger = require("./logger");
+const {
+  createRoutes,
+  createAdminRoutes,
+  getAvailableRoutes
+} = require("./routes");
 module.exports = {
   errorCatcher,
   errorHandler,
@@ -24,5 +29,8 @@ module.exports = {
   createSwaggerSpec,
   generateToken,
   validateAuth,
-  notFoundHandler
+  notFoundHandler,
+  createRoutes,
+  createAdminRoutes,
+  getAvailableRoutes
 };

package/dist/routes/admin/index.js

@@ -0,0 +1,520 @@
+"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
+};

package/dist/routes/index.js

@@ -0,0 +1,75 @@
+"use strict";
+
+// Main routes index for powr-sdk-api
+// This file exports all route handlers for easy integration
+
+const {
+  createAdminRoutes
+} = require('./admin');
+const createRoutes = (app, options = {}) => {
+  const {
+    projectId,
+    baseUrl = '/api',
+    authMiddleware = null,
+    logger = console,
+    mongoUrl = process.env.MONGODB_URI || 'mongodb://localhost:27017/powrbase'
+  } = options;
+
+  // Apply auth middleware if provided
+  if (authMiddleware) {
+    app.use(`${baseUrl}/admin`, authMiddleware);
+  }
+
+  // Initialize admin routes
+  createAdminRoutes(app, {
+    projectId,
+    apiUrl: `${baseUrl}/admin`,
+    authMiddleware,
+    logger,
+    mongoUrl
+  });
+
+  // Health check endpoint
+  app.get(`${baseUrl}/health`, (req, res) => {
+    res.json({
+      success: true,
+      message: 'API is running',
+      projectId,
+      timestamp: new Date().toISOString()
+    });
+  });
+
+  // Project info endpoint
+  app.get(`${baseUrl}/info`, (req, res) => {
+    res.json({
+      success: true,
+      projectId,
+      version: '2.0.1',
+      features: ['forms', 'waitlists', 'slides', 'invoices', 'notifications']
+    });
+  });
+  logger.info('All routes initialized for project:', projectId);
+  return app;
+};
+
+// Utility function to get available routes
+const getAvailableRoutes = () => {
+  return {
+    admin: {
+      forms: ['GET', 'POST', 'PUT', 'DELETE'],
+      waitlists: ['GET', 'POST'],
+      slides: ['GET', 'POST', 'PUT', 'DELETE'],
+      invoices: ['GET', 'POST', 'PUT'],
+      notifications: ['GET', 'POST', 'PUT']
+    },
+    utility: {
+      health: ['GET'],
+      info: ['GET']
+    }
+  };
+};
+module.exports = {
+  createRoutes,
+  createAdminRoutes,
+  getAvailableRoutes
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "powr-sdk-api",
-  "version": "1.5.2",
+  "version": "2.0.2",
   "description": "Shared API core library for PowrStack projects",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -42,7 +42,10 @@
     "jsonwebtoken": "^9.0.2",
     "swagger-jsdoc": "^6.2.8",
     "swagger-ui-express": "^5.0.0",
-    "winston": "^3.17.0"
+    "winston": "^3.17.0",
+    "mongodb": "^6.3.0",
+    "multer": "^1.4.5-lts.1",
+    "bcrypt": "^5.1.1"
   },
   "devDependencies": {
     "@babel/cli": "^7.23.9",