powr-sdk-api 1.2.2 → 1.3.1

package/dist/index.js

@@ -1,24 +1,24 @@
 "use strict";
 
-const errorMiddleware = require('./middleware/error');
-const responseMiddleware = require('./middleware/response');
-const requestMiddleware = require('./middleware/request');
-const createSwaggerSpec = require('./swagger');
-const logger = require('./services/logger');
 const {
-  generateToken
-} = require('./utils/auth');
+  errorCatcher,
+  errorHandler
+} = require("./middleware/error");
+const {
+  requestHandler
+} = require("./middleware/request");
 const {
-  validateToken
-} = require('./middleware/auth');
+  validateAuth,
+  generateToken
+} = require("./middleware/auth");
+const createSwaggerSpec = require("./swagger");
+const logger = require("./logger");
 module.exports = {
-  errorCatcher: errorMiddleware.errorCatcher,
-  errorHandler: errorMiddleware.errorHandler,
-  requestLogger: requestMiddleware.requestLogger,
-  responseFormatter: responseMiddleware.responseFormatter,
-  responseLogger: responseMiddleware.responseLogger,
+  errorCatcher,
+  errorHandler,
+  requestHandler,
   logger,
   createSwaggerSpec,
   generateToken,
-  validateToken
+  validateAuth
 };

package/dist/logger/index.js

@@ -0,0 +1,35 @@
+"use strict";
+
+const winston = require('winston');
+const {
+  S3Transport
+} = require('./s3');
+
+// Custom format for logs
+const logFormat = winston.format.combine(winston.format.timestamp(), winston.format.errors({
+  stack: true
+}), winston.format.json());
+
+// Create base transports array with console transport
+const transports = [new winston.transports.Console()];
+
+// Add S3 transport only in production
+if (process.env.NODE_ENV === 'production') {
+  transports.push(new S3Transport({
+    bucket: process.env.AWS_LOG_BUCKET_NAME,
+    prefix: 'logs',
+    bufferSize: 100,
+    flushInterval: 5000
+  }));
+}
+
+// Create the logger
+const logger = winston.createLogger({
+  level: process.env.LOG_LEVEL || 'info',
+  format: logFormat,
+  defaultMeta: {
+    service: process.env.LOG_SERVICE_NAME
+  },
+  transports
+});
+module.exports = logger;

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

@@ -1,18 +1,23 @@
 "use strict";
 
-const jwt = require('jsonwebtoken');
-// const User = require('../models/user');
-
-exports.validateToken = async (req, res, next) => {
+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 (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);
+      return res.error("Not authorized to access this route", 401);
     }
     try {
       // Verify token
@@ -29,12 +34,32 @@ exports.validateToken = async (req, res, next) => {
       req.userId = decoded.userId;
       next();
     } catch (error) {
-      return res.error('Not authorized to access this route', 401, error);
+      return res.error("Not authorized to access this route", 401, error);
     }
   } catch (error) {
-    return res.error('Error authenticating user', 500, 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) => {
@@ -43,4 +68,9 @@ exports.validateToken = async (req, res, next) => {
 //         }
 //         next();
 //     };
-// };
+// };
+
+module.exports = {
+  validateAuth,
+  generateToken
+};

package/dist/middleware/error.js

@@ -1,17 +1,10 @@
 "use strict";
 
-const logger = require("../services/logger");
 const errorCatcher = fn => (req, res, next) => {
-  Promise.resolve(fn(req, res, next)).catch(next);
+  Promise.resolve(fn(req, res, next)).catch(res.error);
 };
 const errorHandler = (err, req, res, next) => {
-  logger.error("Error occurred", {
-    error: err.message,
-    stack: err.stack,
-    path: req.path,
-    method: req.method
-  });
-  return res.error(err.message, err.statusCode, err.details);
+  return res.error(err);
 };
 module.exports = {
   errorCatcher,

package/dist/middleware/request.js

@@ -1,22 +1,95 @@
 "use strict";
 
-const logger = require("../services/logger");
-const requestLogger = (req, res, next) => {
+const logger = require("../logger");
+const requestHandler = (req, res, next) => {
   try {
-    // Only log the request body, redacting sensitive information
-    const logBody = {
-      ...req.body
+    // Add request timestamp
+    req.requestTime = new Date().toISOString();
+
+    // Add request ID for tracking
+    req.requestId = req.headers['x-request-id'] || Math.random().toString(36).substring(2, 15);
+
+    // Set default response headers
+    res.setHeader('X-Request-ID', req.requestId);
+    res.setHeader('X-Request-Time', req.requestTime);
+
+    // Log the incoming request with details
+    const requestDetails = {
+      method: req.method,
+      path: req.path,
+      query: req.query,
+      ip: req.ip,
+      userAgent: req.headers['user-agent'],
+      requestId: req.requestId,
+      timestamp: req.requestTime
     };
-    if (logBody.password) logBody.password = "[REDACTED]";
-    if (logBody.token) logBody.token = "[REDACTED]";
-    logger.info(`${req.method} ${req.path}`, logBody);
+
+    // Log request body if present, redacting sensitive information
+    if (Object.keys(req.body).length > 0) {
+      const logBody = {
+        ...req.body
+      };
+      if (logBody.password) logBody.password = "[REDACTED]";
+      if (logBody.token) logBody.token = "[REDACTED]";
+      requestDetails.body = logBody;
+    }
+    logger.info(`Incoming request: ${req.method} ${req.path}`, requestDetails);
+
+    // Add error handler to response object if not already present
+    if (!res.error) {
+      res.error = (message, statusCode = 500, error = null) => {
+        logger.error(message, {
+          statusCode,
+          requestId: req.requestId,
+          error
+        });
+        const response = {
+          success: false,
+          message,
+          requestId: req.requestId
+        };
+
+        // Include error in response if available
+        if (error !== null) {
+          response.error = error;
+        }
+        return res.status(statusCode).json(response);
+      };
+    }
+
+    // Add success handler to response object if not already present
+    if (!res.success) {
+      res.success = (message = 'Success', statusCode = 200, data = null) => {
+        logger.info(message, {
+          statusCode,
+          requestId: req.requestId,
+          data
+        });
+        // Create response object
+        const response = {
+          success: true,
+          message,
+          requestId: req.requestId
+        };
+
+        // Add data to response and log if available
+        if (data !== null) {
+          response.data = data;
+        }
+        return res.status(statusCode).json(response);
+      };
+    }
+
+    // Continue to the next middleware
     next();
   } catch (error) {
-    // If logging fails, still continue with the request
-    console.error("Error logging request:", error);
-    next();
+    logger.error('Error in request handler', {
+      error,
+      requestId: req.requestId
+    });
+    return res.error('Internal server error', 500, error);
   }
 };
 module.exports = {
-  requestLogger
+  requestHandler
 };

package/package.json

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