powr-sdk-api 1.0.0 → 1.1.1

package/dist/middleware/auth.js

@@ -0,0 +1,46 @@
+"use strict";
+
+const jwt = require('jsonwebtoken');
+// const User = require('../models/user');
+
+exports.protect = 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);
+  }
+};
+
+// 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();
+//     };
+// };

package/dist/middleware/error.js

@@ -1,36 +1,19 @@
 "use strict";
 
-/**
- * Error handling middleware for Express applications
- */
-
-class APIError extends Error {
-  constructor(message, statusCode = 500, details = null) {
-    super(message);
-    this.statusCode = statusCode;
-    this.details = details;
-    this.name = 'APIError';
-  }
-}
-const asyncHandler = fn => (req, res, next) => {
+const logger = require("../services/logger");
+const errorCatcher = fn => (req, res, next) => {
   Promise.resolve(fn(req, res, next)).catch(next);
 };
 const errorHandler = (err, req, res, next) => {
-  console.error('Error:', {
-    message: err.message,
+  logger.error("Error occurred", {
+    error: err.message,
     stack: err.stack,
-    details: err.details
-  });
-  const statusCode = err.statusCode || 500;
-  const message = err.message || 'Internal Server Error';
-  res.status(statusCode).json({
-    success: false,
-    message,
-    details: err.details
+    path: req.path,
+    method: req.method
   });
+  return res.error(err.message, err.statusCode, err.details);
 };
 module.exports = {
-  APIError,
-  asyncHandler,
+  errorCatcher,
   errorHandler
 };

package/dist/middleware/logger.js

@@ -5,40 +5,41 @@
  */
 
 const logger = (req, res, next) => {
-  // Log request
-  console.log('Request:', {
-    timestamp: new Date().toISOString(),
-    method: req.method,
-    url: req.url,
-    ip: req.ip,
-    headers: req.headers,
-    body: req.body,
-    query: req.query
-  });
-
-  // Store original send and json methods
-  const originalSend = res.send;
-  const originalJson = res.json;
+  const startTime = Date.now();
 
-  // Override send method to log response
-  res.send = function (body) {
-    console.log('Response:', {
+  // 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(),
-      statusCode: res.statusCode,
-      body: body
+      method: req.method,
+      url: req.originalUrl,
+      ip: req.ip,
+      userAgent: req.get('user-agent'),
+      body: logBody,
+      query: req.query
     });
-    return originalSend.call(this, body);
-  };
+  } catch (error) {
+    console.error("Error logging request:", error);
+  }
 
-  // Override json method to log response
-  res.json = function (body) {
+  // 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,
-      body: body
+      responseTime: `${responseTime}ms`,
+      userAgent: req.get('user-agent'),
+      ip: req.ip
     });
-    return originalJson.call(this, body);
-  };
+  });
   next();
 };
 module.exports = logger;

package/dist/middleware/request.js

@@ -0,0 +1,22 @@
+"use strict";
+
+const logger = require("../services/logger");
+const requestLogger = (req, res, next) => {
+  try {
+    // Only log the request body, redacting sensitive information
+    const logBody = {
+      ...req.body
+    };
+    if (logBody.password) logBody.password = "[REDACTED]";
+    if (logBody.token) logBody.token = "[REDACTED]";
+    logger.info(`${req.method} ${req.path}`, logBody);
+    next();
+  } catch (error) {
+    // If logging fails, still continue with the request
+    console.error("Error logging request:", error);
+    next();
+  }
+};
+module.exports = {
+  requestLogger
+};

package/dist/middleware/response.js

@@ -1,44 +1,53 @@
 "use strict";
 
-/**
- * Response formatting middleware for Express applications
- */
-
-const responseHandler = (req, res, next) => {
+const logger = require('../services/logger');
+const responseFormatter = (req, res, next) => {
   // Add success method to response object
-  res.success = function (data = null, message = 'Success', statusCode = 200) {
-    return this.status(statusCode).json({
+  res.success = function (message = 'Success', statusCode = 200, data = null) {
+    const response = {
       success: true,
-      message,
-      data
-    });
+      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, details = null) {
-    return this.status(statusCode).json({
+  res.error = function (message = 'Error', statusCode = 500, error = null) {
+    const response = {
       success: false,
-      message,
-      details
-    });
-  };
-
-  // Store original json method
-  const originalJson = res.json;
+      message
+    };
 
-  // Override json method to ensure consistent format
-  res.json = function (data) {
-    // If response is already formatted, use original json
-    if (data && typeof data === 'object' && 'success' in data) {
-      return originalJson.call(this, data);
+    // Only include details if they're not null
+    if (error !== null) {
+      response.error = error;
     }
-
-    // Format the response
-    return originalJson.call(this, {
-      success: true,
-      data
-    });
+    return this.status(statusCode).json(response);
   };
   next();
 };
-module.exports = responseHandler;
+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/services/logger.js

@@ -0,0 +1,35 @@
+"use strict";
+
+const winston = require('winston');
+const {
+  S3Transport
+} = require('../utils/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: 'justhurt-api'
+  },
+  transports
+});
+module.exports = logger;

package/dist/utils/auth.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const jwt = require('jsonwebtoken');
+
+/**
+ * Generates a JWT token for a user
+ * @param {Object} user - The user object
+ * @returns {string} - The generated JWT token
+ */
+const generateToken = user => {
+  return jwt.sign({
+    userId: user.userId
+  }, process.env.JWT_SECRET, {
+    expiresIn: process.env.JWT_EXPIRES_IN || '24h'
+  });
+};
+module.exports = {
+  generateToken
+};

package/dist/utils/logger.js

@@ -0,0 +1,57 @@
+"use strict";
+
+/**
+ * Logger utility for Express applications
+ */
+
+const winston = require('winston');
+const S3Transport = require('./s3-transport');
+
+/**
+ * Creates a Winston logger instance with configured transports
+ * @param {Object} options - Logger configuration options
+ * @param {string} options.service - Service name for logging
+ * @param {string} options.level - Log level (default: 'info')
+ * @param {Object} options.s3 - S3 transport configuration
+ * @param {string} options.s3.bucket - S3 bucket name
+ * @param {string} options.s3.prefix - S3 key prefix
+ * @param {number} options.s3.bufferSize - Buffer size for S3 uploads
+ * @param {number} options.s3.flushInterval - Flush interval in milliseconds
+ * @returns {winston.Logger} Configured Winston logger instance
+ */
+const createLogger = (options = {}) => {
+  const {
+    service = 'api',
+    level = process.env.LOG_LEVEL || 'info',
+    s3 = null
+  } = options;
+
+  // 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 if configured
+  if (s3 && process.env.NODE_ENV === 'production') {
+    transports.push(new S3Transport({
+      bucket: s3.bucket,
+      prefix: s3.prefix || 'logs',
+      bufferSize: s3.bufferSize || 100,
+      flushInterval: s3.flushInterval || 5000
+    }));
+  }
+
+  // Create and return the logger
+  return winston.createLogger({
+    level,
+    format: logFormat,
+    defaultMeta: {
+      service
+    },
+    transports
+  });
+};
+module.exports = createLogger;

package/dist/utils/s3-transport.js

@@ -0,0 +1,61 @@
+"use strict";
+
+/**
+ * S3 Transport for Winston logger
+ */
+
+const winston = require('winston');
+const {
+  S3Client,
+  PutObjectCommand
+} = require('@aws-sdk/client-s3');
+
+/**
+ * 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 this.s3Client.send(command);
+    } catch (error) {
+      console.error('Error flushing logs to S3:', error);
+      // Put logs back in buffer
+      this.buffer.unshift(...logs);
+    }
+  }
+  log(info, callback) {
+    setImmediate(() => {
+      this.emit('logged', info);
+    });
+    this.buffer.push(info);
+    if (this.buffer.length >= this.bufferSize) {
+      this.flush();
+    }
+    callback();
+  }
+}
+module.exports = S3Transport;

package/dist/utils/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/package.json

@@ -1,60 +1,60 @@
-{
-  "name": "powr-sdk-api",
-  "version": "1.0.0",
-  "description": "Shared API core library for PowrStack projects",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "scripts": {
-    "test": "jest --passWithNoTests",
-    "lint": "eslint .",
-    "build": "babel src -d dist",
-    "prepare": "npm run build",
-    "prepublishOnly": "npm run test"
-  },
-  "keywords": [
-    "api",
-    "express",
-    "middleware",
-    "error-handling",
-    "response-formatting",
-    "logging",
-    "swagger",
-    "documentation"
-  ],
-  "author": "PowrStack",
-  "license": "ISC",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/powrstack/powr-sdk-api.git"
-  },
-  "bugs": {
-    "url": "https://github.com/powrstack/powr-sdk-api/issues"
-  },
-  "homepage": "https://github.com/powrstack/powr-sdk-api#readme",
-  "dependencies": {
-    "express": "^4.18.2",
-    "swagger-jsdoc": "^6.2.8",
-    "swagger-ui-express": "^5.0.0"
-  },
-  "devDependencies": {
-    "@babel/cli": "^7.23.9",
-    "@babel/core": "^7.24.0",
-    "@babel/preset-env": "^7.24.0",
-    "@types/express": "^4.17.21",
-    "@types/swagger-jsdoc": "^6.0.4",
-    "@types/swagger-ui-express": "^4.1.6",
-    "eslint": "^8.57.0",
-    "jest": "^29.7.0",
-    "typescript": "^5.3.3"
-  },
-  "peerDependencies": {
-    "express": "^4.18.2"
-  },
-  "engines": {
-    "node": ">=14.0.0"
-  }
-}
+{
+  "name": "powr-sdk-api",
+  "version": "1.1.1",
+  "description": "Shared API core library for PowrStack projects",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "jest --passWithNoTests",
+    "lint": "eslint .",
+    "build": "babel src -d dist",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run test"
+  },
+  "keywords": [
+    "api",
+    "express",
+    "middleware",
+    "error-handling",
+    "response-formatting",
+    "logging",
+    "swagger",
+    "documentation"
+  ],
+  "author": "PowrStack",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/powrstack/powr-sdk-api.git"
+  },
+  "bugs": {
+    "url": "https://github.com/powrstack/powr-sdk-api/issues"
+  },
+  "homepage": "https://github.com/powrstack/powr-sdk-api#readme",
+  "dependencies": {
+    "express": "^4.18.2",
+    "swagger-jsdoc": "^6.2.8",
+    "swagger-ui-express": "^5.0.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.23.9",
+    "@babel/core": "^7.24.0",
+    "@babel/preset-env": "^7.24.0",
+    "@types/express": "^4.17.21",
+    "@types/swagger-jsdoc": "^6.0.4",
+    "@types/swagger-ui-express": "^4.1.6",
+    "eslint": "^8.57.0",
+    "jest": "^29.7.0",
+    "typescript": "^5.3.3"
+  },
+  "peerDependencies": {
+    "express": "^4.18.2"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}