powr-sdk-api 4.3.12 → 4.3.13

package/dist/admin/waitlists.js

@@ -0,0 +1,94 @@
+"use strict";
+
+const express = require("express");
+const router = express.Router();
+const {
+  getDb
+} = require("../services/mongo");
+
+// Get waitlist entries
+router.get('/', async (req, res) => {
+  const {
+    projectId
+  } = req.query;
+  try {
+    const query = {
+      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({
+      success: true,
+      entries: sortedData
+    });
+  } catch (error) {
+    console.error("Error retrieving waitlist entries:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to retrieve waitlist entries."
+    });
+  }
+});
+
+// Original POST endpoint for adding to waitlist
+router.post("/", async (req, res) => {
+  const {
+    projectId,
+    email
+  } = req.body;
+  try {
+    const existingEntry = await getDb().collection("waitlists").findOne({
+      projectId,
+      email
+    });
+    if (existingEntry) {
+      return res.status(400).json({
+        success: false,
+        message: "You are already in the waitlist "
+      });
+    }
+  } catch (error) {
+    console.error("Error checking waitlist:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to check waitlist due to a server error."
+    });
+  }
+  const waitListData = {
+    projectId,
+    email,
+    createdAt: new Date()
+  };
+  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({
+        success: false,
+        message: "user could not be added."
+      });
+    }
+  } catch (error) {
+    console.error("Error adding user:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to add user due to a server error."
+    });
+  }
+});
+module.exports = router;

package/dist/index.js

@@ -14,7 +14,8 @@ const {
   createSwaggerSpec
 } = require("./swagger");
 const {
-  createPowrRoutes
+  createPowrRoutes,
+  createCommonRoutes
 } = require("./routes");
 const {
   initializeFunctions,
@@ -33,6 +34,7 @@ module.exports = {
   createSwaggerSpec,
   notFoundHandler,
   createPowrRoutes,
+  createCommonRoutes,
   initializeFunctions,
   initializeTools,
   verifyToken,

package/dist/logger/gcs.js

@@ -0,0 +1,78 @@
+"use strict";
+
+const winston = require('winston');
+const {
+  Storage
+} = require('@google-cloud/storage');
+
+// Create GCS client using environment variables for credentials
+const storage = new Storage({
+  projectId: process.env.GCS_PROJECT_ID,
+  credentials: {
+    client_email: process.env.GCS_CLIENT_EMAIL,
+    private_key: process.env.GCS_PRIVATE_KEY ? process.env.GCS_PRIVATE_KEY.replace(/\\n/g, '\n') : undefined
+  }
+});
+
+/**
+ * Custom Winston transport for logging to Google Cloud Storage
+ */
+class GCSTransport extends winston.Transport {
+  constructor(opts) {
+    super(opts);
+    this.bucket = opts.bucket;
+    this.prefix = opts.prefix || '';
+    this.buffer = [];
+    this.bufferSize = opts.bufferSize || 100;
+    this.flushInterval = opts.flushInterval || 5000;
+    this.setupFlushInterval();
+  }
+  setupFlushInterval() {
+    setInterval(() => {
+      this.flush();
+    }, this.flushInterval);
+  }
+  async flush() {
+    if (this.buffer.length === 0) return;
+    const logs = this.buffer.splice(0, this.buffer.length);
+    const date = new Date().toISOString().split('T')[0];
+    const filename = `${this.prefix}/${date}/${Date.now()}.json`;
+    try {
+      const bucket = storage.bucket(this.bucket);
+      const file = bucket.file(filename);
+      await file.save(JSON.stringify(logs), {
+        contentType: 'application/json',
+        metadata: {
+          contentType: 'application/json'
+        }
+      });
+    } catch (error) {
+      console.error('Failed to write logs to Google Cloud Storage:', {
+        error: error.message,
+        code: error.code,
+        bucket: this.bucket,
+        filename: filename,
+        projectId: process.env.GCS_PROJECT_ID,
+        stack: error.stack
+      });
+      // Put the logs back in the buffer
+      this.buffer.unshift(...logs);
+    }
+  }
+  log(info, callback) {
+    setImmediate(() => {
+      this.emit('logged', info);
+    });
+    this.buffer.push({
+      timestamp: new Date().toISOString(),
+      ...info
+    });
+    if (this.buffer.length >= this.bufferSize) {
+      this.flush();
+    }
+    callback();
+  }
+}
+module.exports = {
+  GCSTransport
+};

package/dist/logger/s3.js

@@ -0,0 +1,78 @@
+"use strict";
+
+const winston = require('winston');
+const {
+  S3Client,
+  PutObjectCommand
+} = require('@aws-sdk/client-s3');
+
+// Create S3 client
+const s3Client = new S3Client({
+  region: process.env.AWS_REGION,
+  credentials: {
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
+  }
+});
+
+/**
+ * Custom Winston transport for logging to S3
+ */
+class S3Transport extends winston.Transport {
+  constructor(opts) {
+    super(opts);
+    this.bucket = opts.bucket;
+    this.prefix = opts.prefix || '';
+    this.buffer = [];
+    this.bufferSize = opts.bufferSize || 100;
+    this.flushInterval = opts.flushInterval || 5000;
+    this.setupFlushInterval();
+  }
+  setupFlushInterval() {
+    setInterval(() => {
+      this.flush();
+    }, this.flushInterval);
+  }
+  async flush() {
+    if (this.buffer.length === 0) return;
+    const logs = this.buffer.splice(0, this.buffer.length);
+    const date = new Date().toISOString().split('T')[0];
+    const key = `${this.prefix}/${date}/${Date.now()}.json`;
+    try {
+      const command = new PutObjectCommand({
+        Bucket: this.bucket,
+        Key: key,
+        Body: JSON.stringify(logs),
+        ContentType: 'application/json'
+      });
+      await s3Client.send(command);
+    } catch (error) {
+      console.error('Failed to write logs to S3:', {
+        error: error.message,
+        code: error.code,
+        bucket: this.bucket,
+        key: key,
+        region: process.env.AWS_REGION,
+        stack: error.stack
+      });
+      // Put the logs back in the buffer
+      this.buffer.unshift(...logs);
+    }
+  }
+  log(info, callback) {
+    setImmediate(() => {
+      this.emit('logged', info);
+    });
+    this.buffer.push({
+      timestamp: new Date().toISOString(),
+      ...info
+    });
+    if (this.buffer.length >= this.bufferSize) {
+      this.flush();
+    }
+    callback();
+  }
+}
+module.exports = {
+  S3Transport
+};

package/dist/middleware/auth.js

@@ -0,0 +1,76 @@
+"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

@@ -0,0 +1,45 @@
+"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

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