powr-sdk-api 2.3.7 → 2.4.0

package/dist/config.js

@@ -2,8 +2,6 @@
 
 const config = {
   mongoUri: process.env.POWR_DB_URI,
-  projectId: process.env.PROJECT_ID,
-  jwtToken: process.env.JWT_TOKEN,
-  storageBucket: process.env.STORAGE_BUCKET
+  jwtToken: process.env.JWT_TOKEN
 };
 module.exports = config;

package/dist/index.js

@@ -7,36 +7,20 @@ const {
 const {
   requestHandler
 } = require("./middleware/request");
-const {
-  validateAuth,
-  generateToken
-} = require("./middleware/auth");
 const {
   notFoundHandler
 } = require("./middleware/notfound");
 const {
   createSwaggerSpec
 } = require("./swagger");
-const {
-  cloudLogger
-} = require("./logger");
 const {
   createPowrRoutes
 } = require("./routes");
-const {
-  generateJWTToken,
-  verifyToken
-} = require("./middleware/jwtToken");
 module.exports = {
   errorCatcher,
   errorHandler,
   requestHandler,
-  cloudLogger,
   createSwaggerSpec,
-  generateToken,
-  validateAuth,
   notFoundHandler,
-  createPowrRoutes,
-  generateJWTToken,
-  verifyToken
+  createPowrRoutes
 };

package/dist/middleware/jwtToken.js

@@ -1,9 +1,6 @@
 "use strict";
 
 const jwt = require('jsonwebtoken');
-const {
-  ObjectId
-} = require('mongodb');
 const config = require('../config');
 const generateJWTToken = (user, profile = null) => {
   return jwt.sign({
@@ -29,6 +26,12 @@ const verifyToken = async (req, res, next) => {
 
     // Extract token (remove 'Bearer ' if present)
     const token = authHeader.startsWith("Bearer ") ? authHeader.slice(7) : authHeader;
+    if (!token) {
+      return res.status(401).json({
+        success: false,
+        message: 'No token provided'
+      });
+    }
 
     // Verify JWT token
     const decoded = jwt.verify(token, config.jwtToken);

package/dist/middleware/projectId.js

@@ -0,0 +1,42 @@
+"use strict";
+
+const config = require('../config');
+
+/**
+ * Middleware to inject projectId into requests
+ * @param {Object} options - Configuration options
+ * @param {boolean} options.isCentralService - Whether this is a central service (like powr-base-cloud)
+ * @returns {Function} Express middleware function
+ */
+const injectProjectId = (options = {}) => {
+  const isCentralService = options.isCentralService || false;
+  return (req, res, next) => {
+    try {
+      if (isCentralService) {
+        // For central services, get projectId from request
+        const projectId = req.query.projectId || req.body.projectId;
+        if (!projectId) {
+          return res.status(400).json({
+            success: false,
+            message: 'projectId is required for central services'
+          });
+        }
+        req.projectId = projectId;
+      } else {
+        // For individual APIs, use config.projectId
+        req.projectId = config.projectId;
+      }
+      next();
+    } catch (error) {
+      console.error('❌ ProjectId injection error:', error.message);
+      return res.status(500).json({
+        success: false,
+        message: 'Configuration error',
+        error: error.message
+      });
+    }
+  };
+};
+module.exports = {
+  injectProjectId
+};

package/dist/routes/auth.js

@@ -4,14 +4,13 @@ const express = require("express");
 const router = express.Router();
 const {
   getDb
-} = require("../services/dbService");
+} = require("../services/mongo");
 const {
   ObjectId
 } = require("mongodb");
 const bcrypt = require("bcrypt");
 const {
-  generateJWTToken,
-  verifyToken
+  generateJWTToken
 } = require("../middleware/jwtToken");
 const {
   config
@@ -23,9 +22,10 @@ router.post("/register", async (req, res) => {
     fullName,
     username,
     phoneOrEmail,
-    password,
-    projectId
+    password
   } = req.body;
+  const projectId = req.projectId; // Use middleware-injected projectId
+
   try {
     if (!(username || phoneOrEmail)) {
       return res.status(400).json({
@@ -45,14 +45,6 @@ router.post("/register", async (req, res) => {
         message: "Full name is required"
       });
     }
-
-    // if (!projectId) {
-    //   return res.status(400).json({
-    //     success: false,
-    //     message: "Project ID is required"
-    //   });
-    // }
-
     let q = username ? {
       username: username
     } : {
@@ -109,9 +101,10 @@ router.post("/login", async (req, res) => {
   const {
     username,
     phoneOrEmail,
-    password,
-    projectId
+    password
   } = req.body;
+  const projectId = req.projectId; // Use middleware-injected projectId
+
   try {
     if (!(username || phoneOrEmail)) {
       return res.status(400).json({
@@ -185,13 +178,31 @@ router.post("/login", async (req, res) => {
     const token = generateJWTToken(user, profile);
     const {
       password: _,
+      _id,
       ...userWithoutPassword
     } = user;
+    let mergedUser = {
+      ...userWithoutPassword,
+      powrId: user._id
+    };
+    if (profile) {
+      const {
+        _id,
+        userId,
+        projectId,
+        createdAt,
+        updatedAt,
+        ...profileData
+      } = profile;
+      mergedUser = {
+        ...mergedUser,
+        ...profileData
+      };
+    }
     return res.status(200).json({
       success: true,
       message: "Login successful",
-      user: userWithoutPassword,
-      profile: profile,
+      user: mergedUser,
       token: token
     });
   } catch (error) {

package/dist/routes/files.js

@@ -1,16 +1,12 @@
 "use strict";
 
 const express = require('express');
+const router = express.Router();
 const multer = require('multer');
 // const { uploadToGCS, bucket } = require('../uploadToGCS')
-const {
-  bucket,
-  uploadToGCS,
-  bucketName
-} = require('../uploadToGCS.js');
+// const { bucket, uploadToGCS, bucketName } = require('../uploadToGCS.js')
 // const uploadToGCS = require('../uploadToGCS.js')
 
-const router = express.Router();
 const upload = multer();
 router.post('/', upload.single('file'), async (req, res) => {
   try {
@@ -20,11 +16,13 @@ router.post('/', upload.single('file'), async (req, res) => {
         message: 'No file uploaded'
       });
     }
-    const url = await uploadToGCS(req.file);
+
+    // const url = await uploadToGCS(req.file);
+
     return res.status(200).json({
       status: 'success',
-      message: 'File uploaded successfully',
-      url
+      message: 'File uploaded successfully'
+      // url,
     });
   } catch (err) {
     console.error('Error uploading file:', err);
@@ -37,12 +35,13 @@ router.post('/', upload.single('file'), async (req, res) => {
 });
 router.get('/', async (req, res) => {
   try {
-    const [files] = await bucket.getFiles();
-    const bucketName = bucket.name;
-    const imageUrls = files.map(file => `https://storage.googleapis.com/${bucketName}/${file.name}`);
+    // const [files] = await bucket.getFiles();
+    // const bucketName = bucket.name;
+    // const imageUrls = files.map(file => `https://storage.googleapis.com/${bucketName}/${file.name}`);
+
     return res.status(200).json({
-      message: 'Images fetched successfully',
-      images: imageUrls
+      message: 'Images fetched successfully'
+      // images: imageUrls,
     });
   } catch (err) {
     console.error('Error listing files from GCS:', err);

package/dist/routes/forms.js

@@ -6,7 +6,7 @@ const multer = require('multer');
 const path = require('path');
 const {
   getDb
-} = require('../services/dbService');
+} = require("../services/mongo");
 const upload = multer({
   storage: multer.memoryStorage(),
   fileFilter: function (req, file, cb) {
@@ -239,4 +239,52 @@ router.post('/create-form', upload.single('jsonFile'), async (req, res) => {
     });
   }
 });
+
+// Get form submissions
+router.get("/submissions", async (req, res) => {
+  const projectId = req.projectId; // Use middleware-injected projectId
+
+  try {
+    const db = await getDb();
+    const submissions = await db.collection("formSubmissions").find({
+      projectId
+    }).toArray();
+    return res.json({
+      success: true,
+      data: submissions
+    });
+  } catch (error) {
+    console.error("Error fetching form submissions:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to fetch form submissions."
+    });
+  }
+});
+
+// Get form submissions by form ID
+router.get("/submissions/:formId", async (req, res) => {
+  const {
+    formId
+  } = req.params;
+  const projectId = req.projectId; // Use middleware-injected projectId
+
+  try {
+    const db = await getDb();
+    const submissions = await db.collection("formSubmissions").find({
+      formId,
+      projectId
+    }).toArray();
+    return res.json({
+      success: true,
+      data: submissions
+    });
+  } catch (error) {
+    console.error("Error fetching form submissions:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to fetch form submissions."
+    });
+  }
+});
 module.exports = router;

package/dist/routes/index.js

@@ -1,10 +1,13 @@
 "use strict";
 
 const express = require('express');
+const {
+  injectProjectId
+} = require('../middleware/projectId');
 
 // Import all route modules
 const commentsRoutes = require('./comments');
-// const filesRoutes = require('./files'); // Commented out for now
+const filesRoutes = require('./files');
 const formsRoutes = require('./forms');
 const invoiceRoutes = require('./invoice');
 const likesRoutes = require('./likes');
@@ -14,34 +17,16 @@ const usersRoutes = require('./users');
 const waitlistsRoutes = require('./waitlists');
 const activitiesRoutes = require('./activities');
 const authRoutes = require('./auth');
-const blogsRoutes = require('./blogs');
 const slidesRoutes = require('./slides');
 const notificationsRoutes = require('./notifications');
-const createPowrRoutes = () => {
+const profilesRoutes = require('./profiles');
+const createPowrRoutes = (options = {}) => {
   const router = express.Router();
 
-  // Middleware to inject projectId into all requests
-  router.use((req, res, next) => {
-    try {
-      const {
-        getConfig
-      } = require('../config');
-      const config = getConfig();
-      req.projectId = config.projectId;
-    } catch (error) {
-      console.error('❌ Config error:', error.message);
-      return res.status(500).json({
-        success: false,
-        message: 'Configuration error',
-        error: error.message
-      });
-    }
-    next();
-  });
-
-  // Mount all route modules
+  // Use the dedicated projectId injection middleware
+  router.use(injectProjectId(options));
   router.use('/comments', commentsRoutes);
-  // router.use('/files', filesRoutes); // Commented out for now
+  router.use('/files', filesRoutes);
   router.use('/forms', formsRoutes);
   router.use('/invoice', invoiceRoutes);
   router.use('/likes', likesRoutes);
@@ -51,9 +36,9 @@ const createPowrRoutes = () => {
   router.use('/waitlists', waitlistsRoutes);
   router.use('/activities', activitiesRoutes);
   router.use('/auth', authRoutes);
-  router.use('/blogs', blogsRoutes);
   router.use('/slides', slidesRoutes);
   router.use('/notifications', notificationsRoutes);
+  router.use('/profiles', profilesRoutes);
   return router;
 };
 module.exports = {

package/dist/routes/plexx.js

@@ -5,11 +5,6 @@ const router = express.Router();
 const {
   getDb
 } = require("../services/mongo");
-const data = [{
-  age: 12
-}, {
-  age: 45
-}];
 router.get("/:route", async (req, res) => {
   const {
     route

package/dist/routes/profiles.js

@@ -0,0 +1,60 @@
+"use strict";
+
+const express = require("express");
+const router = express.Router();
+const {
+  getDb
+} = require("../services/mongo");
+
+// Get all users for a project
+router.get("/", async (req, res) => {
+  try {
+    const {
+      projectId
+    } = req.query;
+    const profiles = await getDb().collection("profiles").find({
+      projectId: projectId
+    }).toArray();
+    if (profiles.length === 0) {
+      return res.status(200).json({
+        success: true,
+        users: []
+      });
+    }
+
+    // Get core user data for all profiles
+    const userIds = profiles.map(profile => profile.userId);
+    const users = await getDb().collection("users").find({
+      _id: {
+        $in: userIds
+      }
+    }).toArray();
+
+    // Create a map for quick lookup
+    const usersMap = users.reduce((acc, user) => {
+      const {
+        password,
+        ...userWithoutPassword
+      } = user;
+      acc[user._id.toString()] = userWithoutPassword;
+      return acc;
+    }, {});
+
+    // Merge user and profile data
+    const usersWithProfiles = profiles.map(profile => ({
+      ...usersMap[profile.userId.toString()],
+      ...profile
+    }));
+    return res.status(200).json({
+      success: true,
+      users: usersWithProfiles
+    });
+  } catch (error) {
+    console.error("Error fetching project users:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to fetch project users"
+    });
+  }
+});
+module.exports = router;

package/dist/routes/routes.js

@@ -4,7 +4,7 @@ const express = require("express");
 const router = express.Router();
 const {
   getDb
-} = require("../services/dbService");
+} = require("../services/mongo");
 
 // Get all routes entries
 router.get('/', async (req, res) => {

package/dist/routes/users.js

@@ -8,167 +8,223 @@ const {
 const {
   ObjectId
 } = require("mongodb");
-router.post("/", async (req, res) => {
+const {
+  verifyToken
+} = require("../middleware/jwtToken");
+
+// Create User
+router.post("/", verifyToken, async (req, res) => {
   const {
-    projectId,
     phoneNumber,
     email,
     ...userData
   } = req.body;
-  if (!phoneNumber && !email) {
-    return res.status(400).json({
-      success: false,
-      message: "phoneNumber or email is required."
-    });
-  }
-  const user = {
-    projectId,
-    phoneNumber,
-    email,
-    ...userData,
-    createdAt: new Date()
-  };
+  const projectId = req.projectId; // Use middleware-injected projectId
+
   try {
-    const usersCollection = getDb().collection("users");
-    if (phoneNumber) {
-      const existingByPhone = await usersCollection.findOne({
-        projectId,
+    // Check if user already exists
+    const existingUser = await getDb().collection("users").findOne({
+      $or: [{
         phoneNumber
-      });
-      if (existingByPhone) {
-        return res.status(409).json({
-          success: false,
-          message: "Phone number already exists."
-        });
-      }
-    }
-    if (email) {
-      const existingByEmail = await usersCollection.findOne({
-        projectId,
+      }, {
         email
+      }]
+    });
+    if (existingUser) {
+      return res.status(400).json({
+        success: false,
+        message: "User with this phone number or email already exists"
       });
-      if (existingByEmail) {
-        return res.status(409).json({
-          success: false,
-          message: "Email already exists."
-        });
-      }
     }
-    const result = await getDb().collection("users").insertOne(user);
-    return res.status(200).json({
+    const newUser = {
+      ...userData,
+      phoneNumber,
+      email,
+      createdAt: new Date(),
+      updatedAt: new Date()
+    };
+    const result = await getDb().collection("users").insertOne(newUser);
+
+    // Create profile for this project
+    const newProfile = {
+      userId: result.insertedId,
+      projectId: projectId,
+      access: userData.access || 1,
+      createdAt: new Date(),
+      updatedAt: new Date()
+    };
+    await getDb().collection("profiles").insertOne(newProfile);
+    return res.status(201).json({
       success: true,
-      message: "User created successfully.",
+      message: "User created successfully",
       userId: result.insertedId
     });
   } catch (error) {
     console.error("Error creating user:", error);
     return res.status(500).json({
       success: false,
-      message: "Internal server error."
+      message: "Failed to create user."
     });
   }
 });
-router.get("/", async (req, res) => {
+
+// Get All Users
+router.get("/", verifyToken, async (req, res) => {
   const {
-    projectId,
     _id,
     phoneNumber,
     email
   } = req.query;
-  if (!_id && !phoneNumber && !email) {
-    return res.status(400).json({
-      success: false,
-      message: "no filters provided.",
-      users: []
-    });
-  }
-  const filter = {
-    projectId
-  };
-  if (_id) {
-    try {
-      filter._id = new ObjectId(_id);
-    } catch (e) {
-      return res.status(400).json({
-        success: false,
-        message: "Invalid _id format."
-      });
-    }
-  }
-  if (phoneNumber) {
-    filter.phoneNumber = phoneNumber;
-  }
-  if (email) {
-    filter.email = email;
-  }
+  const projectId = req.projectId; // Use middleware-injected projectId
+
   try {
-    const users = await getDb().collection("users").find(filter).toArray();
-    return res.status(200).json({
+    let query = {};
+
+    // Add filters if provided
+    if (_id) {
+      query._id = new ObjectId(_id);
+    }
+    if (phoneNumber) {
+      query.phoneNumber = phoneNumber;
+    }
+    if (email) {
+      query.email = email;
+    }
+    const users = await getDb().collection("users").find(query).toArray();
+
+    // Get profiles for this project
+    const userIds = users.map(user => user._id);
+    const profiles = await getDb().collection("profiles").find({
+      userId: {
+        $in: userIds
+      },
+      projectId: projectId
+    }).toArray();
+
+    // Merge user data with profile data
+    const usersWithProfiles = users.map(user => {
+      const profile = profiles.find(p => p.userId.toString() === user._id.toString());
+      return {
+        ...user,
+        access: profile ? profile.access : 1,
+        projectId: projectId
+      };
+    });
+    return res.json({
       success: true,
-      message: "Users fetched successfully.",
-      users
+      data: usersWithProfiles
     });
   } catch (error) {
     console.error("Error fetching users:", error);
     return res.status(500).json({
       success: false,
-      message: "Internal server error."
+      message: "Failed to fetch users."
     });
   }
 });
-router.post("/getOrCreate", async (req, res) => {
+
+// Update User
+router.put("/:id", verifyToken, async (req, res) => {
+  const {
+    id
+  } = req.params;
   const {
-    projectId,
     phoneNumber,
     email,
     ...userData
   } = req.body;
-  if (!phoneNumber && !email) {
-    return res.status(400).json({
-      success: false,
-      message: "phoneNumber or email is required."
-    });
-  }
-  const user = {
-    projectId,
-    phoneNumber,
-    email,
-    ...userData,
-    createdAt: new Date()
-  };
+  const projectId = req.projectId; // Use middleware-injected projectId
+
   try {
-    const usersCollection = getDb().collection("users");
-    let existingUser = null;
-    if (phoneNumber) {
-      existingUser = await usersCollection.findOne({
-        projectId,
-        phoneNumber
+    // Check if user exists
+    const existingUser = await getDb().collection("users").findOne({
+      _id: new ObjectId(id)
+    });
+    if (!existingUser) {
+      return res.status(404).json({
+        success: false,
+        message: "User not found"
       });
     }
-    if (!existingUser && email) {
-      existingUser = await usersCollection.findOne({
-        projectId,
-        email
+
+    // Update user
+    const updateData = {
+      ...userData,
+      phoneNumber,
+      email,
+      updatedAt: new Date()
+    };
+    await getDb().collection("users").updateOne({
+      _id: new ObjectId(id)
+    }, {
+      $set: updateData
+    });
+
+    // Update profile if access level is provided
+    if (userData.access !== undefined) {
+      await getDb().collection("profiles").updateOne({
+        userId: new ObjectId(id),
+        projectId: projectId
+      }, {
+        $set: {
+          access: userData.access,
+          updatedAt: new Date()
+        }
+      }, {
+        upsert: true
       });
     }
-    if (existingUser) {
-      return res.status(200).json({
-        success: true,
-        message: "User already exists.",
-        userId: existingUser._id
+    return res.json({
+      success: true,
+      message: "User updated successfully"
+    });
+  } catch (error) {
+    console.error("Error updating user:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to update user."
+    });
+  }
+});
+
+// Delete User
+router.delete("/:id", verifyToken, async (req, res) => {
+  const {
+    id
+  } = req.params;
+  const projectId = req.projectId; // Use middleware-injected projectId
+
+  try {
+    // Check if user exists
+    const existingUser = await getDb().collection("users").findOne({
+      _id: new ObjectId(id)
+    });
+    if (!existingUser) {
+      return res.status(404).json({
+        success: false,
+        message: "User not found"
       });
     }
-    const result = await usersCollection.insertOne(user);
-    return res.status(200).json({
+
+    // Delete user
+    await getDb().collection("users").deleteOne({
+      _id: new ObjectId(id)
+    });
+
+    // Delete profile for this project
+    await getDb().collection("profiles").deleteOne({
+      userId: new ObjectId(id),
+      projectId: projectId
+    });
+    return res.json({
       success: true,
-      message: "User created successfully.",
-      userId: result.insertedId
+      message: "User deleted successfully"
     });
   } catch (error) {
-    console.error("Error creating or fetching user:", error);
+    console.error("Error deleting user:", error);
     return res.status(500).json({
       success: false,
-      message: "Internal server error."
+      message: "Failed to delete user."
     });
   }
 });

package/dist/routes/waitlists.js

@@ -5,47 +5,47 @@ const router = express.Router();
 const {
   getDb
 } = require("../services/mongo");
+const {
+  ObjectId
+} = require("mongodb");
+
+// Get all waitlists
+router.get("/", async (req, res) => {
+  const projectId = req.projectId; // Use middleware-injected projectId
 
-// Get waitlist entries
-router.get('/', async (req, res) => {
-  const {
-    projectId
-  } = req.query;
   try {
-    const query = {
+    const waitlists = await getDb().collection("waitlists").find({
       projectId
-    };
-    console.log("Filter.....:", query);
-    const waitlistData = await getDb().collection("waitlists").find(query).toArray();
-    if (!waitlistData || waitlistData.length === 0) {
-      console.log("Data not found.");
-      return res.status(200).json({
-        success: true,
-        entries: []
-      });
-    }
-    const sortedData = waitlistData.sort((a, b) => new Date(b === null || b === void 0 ? void 0 : b.createdAt) - new Date(a === null || a === void 0 ? void 0 : a.createdAt));
-    console.log("Waitlist entries retrieved and sorted:", sortedData);
-    return res.status(200).json({
+    }).toArray();
+    return res.json({
       success: true,
-      entries: sortedData
+      data: waitlists
     });
   } catch (error) {
-    console.error("Error retrieving waitlist entries:", error);
+    console.error("Error fetching waitlists:", error);
     return res.status(500).json({
       success: false,
-      message: "Failed to retrieve waitlist entries."
+      message: "Failed to fetch waitlists."
     });
   }
 });
 
-// Original POST endpoint for adding to waitlist
+// Add email to waitlist
 router.post("/", async (req, res) => {
   const {
-    projectId,
     email
   } = req.body;
+  const projectId = req.projectId; // Use middleware-injected projectId
+
   try {
+    if (!email) {
+      return res.status(400).json({
+        success: false,
+        message: "Email is required"
+      });
+    }
+
+    // Check if email already exists in waitlist
     const existingEntry = await getDb().collection("waitlists").findOne({
       projectId,
       email
@@ -53,41 +53,56 @@ router.post("/", async (req, res) => {
     if (existingEntry) {
       return res.status(400).json({
         success: false,
-        message: "You are already in the waitlist "
+        message: "Email already exists in waitlist"
       });
     }
+    const newEntry = {
+      projectId,
+      email,
+      createdAt: new Date()
+    };
+    const result = await getDb().collection("waitlists").insertOne(newEntry);
+    return res.status(201).json({
+      success: true,
+      message: "Email added to waitlist successfully",
+      id: result.insertedId
+    });
   } catch (error) {
-    console.error("Error checking waitlist:", error);
+    console.error("Error adding to waitlist:", error);
     return res.status(500).json({
       success: false,
-      message: "Failed to check waitlist due to a server error."
+      message: "Failed to add to waitlist."
     });
   }
-  const waitListData = {
-    projectId,
-    email,
-    createdAt: new Date()
-  };
+});
+
+// Remove email from waitlist
+router.delete("/:id", async (req, res) => {
+  const {
+    id
+  } = req.params;
+  const projectId = req.projectId; // Use middleware-injected projectId
+
   try {
-    const result = await getDb().collection("waitlists").insertOne(waitListData);
-    if (result && result.insertedId) {
-      return res.status(200).json({
-        success: true,
-        message: "you are added in the waitist",
-        userId: result.insertedId
-      });
-    } else {
-      console.error("Insert operation failed. Result:", result);
-      return res.status(500).json({
+    const result = await getDb().collection("waitlists").deleteOne({
+      _id: new ObjectId(id),
+      projectId
+    });
+    if (result.deletedCount === 0) {
+      return res.status(404).json({
         success: false,
-        message: "user could not be added."
+        message: "Waitlist entry not found"
       });
     }
+    return res.json({
+      success: true,
+      message: "Email removed from waitlist successfully"
+    });
   } catch (error) {
-    console.error("Error adding user:", error);
+    console.error("Error removing from waitlist:", error);
     return res.status(500).json({
       success: false,
-      message: "Failed to add user due to a server error."
+      message: "Failed to remove from waitlist."
     });
   }
 });

package/dist/services/dbService.js

@@ -3,38 +3,40 @@
 const {
   MongoClient
 } = require('mongodb');
-
-// Database service with lazy connection
-let client = null;
-let db = null;
-const getDb = async () => {
-  // Return existing connection if available
-  if (db) {
-    return db;
-  }
-
-  // Connect only when first needed
+const {
+  config
+} = require('../config');
+const mongoClient = new MongoClient(config.mongoUri, {
+  maxPoolSize: 10,
+  serverSelectionTimeoutMS: 5000,
+  socketTimeoutMS: 45000
+});
+let db;
+async function connect() {
   try {
-    const config = require('../config').getConfig();
-    client = new MongoClient(config.mongoUri);
-    await client.connect();
-    db = client.db();
-    console.log('✅ Connected to MongoDB via SDK (lazy connection)');
-    return db;
+    await mongoClient.connect();
+    db = mongoClient.db();
+    console.log("Connected to MongoDB via SDK");
   } catch (error) {
-    console.error('❌ MongoDB connection error:', error);
-    throw error;
+    console.error("Failed to connect to MongoDB:", error);
+    process.exit(1);
   }
-};
+}
+function getDb() {
+  if (!db) {
+    throw new Error("Database not initialized. Call connectToMongo() first.");
+  }
+  return db;
+}
 const closeConnection = async () => {
-  if (client) {
-    await client.close();
-    client = null;
+  if (mongoClient) {
+    await mongoClient.close();
     db = null;
     console.log('✅ MongoDB connection closed');
   }
 };
 module.exports = {
+  connect,
   getDb,
   closeConnection
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "powr-sdk-api",
-  "version": "2.3.7",
+  "version": "2.4.0",
   "description": "Shared API core library for PowrStack projects",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",