nexpgen 1.0.0

package/src/templates/helpers/imageUpload.template

@@ -0,0 +1,191 @@
+{{#if isClass}}
+const multer = require('multer');
+const path = require('path');
+const fs = require('fs');
+
+class ImageUploadHelper {
+  constructor() {
+    this.uploadDir = path.join(process.cwd(), 'config', 'uploads', 'images');
+    this.publicDir = path.join(process.cwd(), 'public', 'images');
+    this.storage = this.setupStorage();
+    this.upload = this.setupMulter();
+    this.ensureDirectories();
+  }
+
+  ensureDirectories() {
+    // Ensure upload directory exists
+    if (!fs.existsSync(this.uploadDir)) {
+      fs.mkdirSync(this.uploadDir, { recursive: true });
+    }
+    // Ensure public images directory exists
+    if (!fs.existsSync(this.publicDir)) {
+      fs.mkdirSync(this.publicDir, { recursive: true });
+    }
+  }
+
+  setupStorage() {
+    return multer.diskStorage({
+      destination: (req, file, cb) => {
+        cb(null, this.uploadDir);
+      },
+      filename: (req, file, cb) => {
+        const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
+        const ext = path.extname(file.originalname);
+        cb(null, file.fieldname + '-' + uniqueSuffix + ext);
+      }
+    });
+  }
+
+  setupMulter() {
+    const fileFilter = (req, file, cb) => {
+      const allowedTypes = /jpeg|jpg|png|gif|webp/;
+      const extname = allowedTypes.test(path.extname(file.originalname).toLowerCase());
+      const mimetype = allowedTypes.test(file.mimetype);
+
+      if (mimetype && extname) {
+        return cb(null, true);
+      } else {
+        cb(new Error('Only image files are allowed!'));
+      }
+    };
+
+    return multer({
+      storage: this.storage,
+      limits: {
+        fileSize: 5 * 1024 * 1024 // 5MB limit
+      },
+      fileFilter: fileFilter
+    });
+  }
+
+  getSingleUpload(fieldName) {
+    return this.upload.single(fieldName);
+  }
+
+  getMultipleUpload(fieldName, maxCount = 5) {
+    return this.upload.array(fieldName, maxCount);
+  }
+
+  deleteFile(filePath) {
+    try {
+      const fullPath = path.isAbsolute(filePath) 
+        ? filePath 
+        : path.join(this.uploadDir, filePath);
+      
+      if (fs.existsSync(fullPath)) {
+        fs.unlinkSync(fullPath);
+        return true;
+      }
+      return false;
+    } catch (error) {
+      console.error(`Error deleting file: ${error.message}`);
+      return false;
+    }
+  }
+
+  getUploadPath() {
+    return this.uploadDir;
+  }
+
+  getPublicPath() {
+    return this.publicDir;
+  }
+}
+
+module.exports = new ImageUploadHelper();
+{{else}}
+const multer = require('multer');
+const path = require('path');
+const fs = require('fs');
+
+const uploadDir = path.join(process.cwd(), 'config', 'uploads', 'images');
+const publicDir = path.join(process.cwd(), 'public', 'images');
+
+const ensureDirectories = () => {
+  // Ensure upload directory exists
+  if (!fs.existsSync(uploadDir)) {
+    fs.mkdirSync(uploadDir, { recursive: true });
+  }
+  // Ensure public images directory exists
+  if (!fs.existsSync(publicDir)) {
+    fs.mkdirSync(publicDir, { recursive: true });
+  }
+};
+
+ensureDirectories();
+
+const setupStorage = () => {
+  return multer.diskStorage({
+    destination: (req, file, cb) => {
+      cb(null, uploadDir);
+    },
+    filename: (req, file, cb) => {
+      const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
+      const ext = path.extname(file.originalname);
+      cb(null, file.fieldname + '-' + uniqueSuffix + ext);
+    }
+  });
+};
+
+const fileFilter = (req, file, cb) => {
+  const allowedTypes = /jpeg|jpg|png|gif|webp/;
+  const extname = allowedTypes.test(path.extname(file.originalname).toLowerCase());
+  const mimetype = allowedTypes.test(file.mimetype);
+
+  if (mimetype && extname) {
+    return cb(null, true);
+  } else {
+    cb(new Error('Only image files are allowed!'));
+  }
+};
+
+const upload = multer({
+  storage: setupStorage(),
+  limits: {
+    fileSize: 5 * 1024 * 1024 // 5MB limit
+  },
+  fileFilter: fileFilter
+});
+
+const getSingleUpload = (fieldName) => {
+  return upload.single(fieldName);
+};
+
+const getMultipleUpload = (fieldName, maxCount = 5) => {
+  return upload.array(fieldName, maxCount);
+};
+
+const deleteFile = (filePath) => {
+  try {
+    const fullPath = path.isAbsolute(filePath) 
+      ? filePath 
+      : path.join(uploadDir, filePath);
+    
+    if (fs.existsSync(fullPath)) {
+      fs.unlinkSync(fullPath);
+      return true;
+    }
+    return false;
+  } catch (error) {
+    console.error(`Error deleting file: ${error.message}`);
+    return false;
+  }
+};
+
+const getUploadPath = () => {
+  return uploadDir;
+};
+
+const getPublicPath = () => {
+  return publicDir;
+};
+
+module.exports = {
+  getSingleUpload,
+  getMultipleUpload,
+  deleteFile,
+  getUploadPath,
+  getPublicPath
+};
+{{/if}}
+

package/src/templates/helpers/timeConverter.template

@@ -0,0 +1,171 @@
+{{#if isClass}}
+class TimeConverterHelper {
+  constructor() {
+    this.timeZones = {
+      UTC: 'UTC',
+      EST: 'America/New_York',
+      PST: 'America/Los_Angeles',
+      GMT: 'Europe/London',
+      IST: 'Asia/Kolkata'
+    };
+  }
+
+  toUTC(date) {
+    return new Date(date.toUTCString());
+  }
+
+  toLocal(date, timeZone = 'UTC') {
+    return new Date(date.toLocaleString('en-US', { timeZone }));
+  }
+
+  format(date, format = 'YYYY-MM-DD HH:mm:ss') {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    const seconds = String(date.getSeconds()).padStart(2, '0');
+
+    return format
+      .replace('YYYY', year)
+      .replace('MM', month)
+      .replace('DD', day)
+      .replace('HH', hours)
+      .replace('mm', minutes)
+      .replace('ss', seconds);
+  }
+
+  addDays(date, days) {
+    const result = new Date(date);
+    result.setDate(result.getDate() + days);
+    return result;
+  }
+
+  addHours(date, hours) {
+    const result = new Date(date);
+    result.setHours(result.getHours() + hours);
+    return result;
+  }
+
+  addMinutes(date, minutes) {
+    const result = new Date(date);
+    result.setMinutes(result.getMinutes() + minutes);
+    return result;
+  }
+
+  differenceInDays(date1, date2) {
+    const diffTime = Math.abs(date2 - date1);
+    return Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+  }
+
+  differenceInHours(date1, date2) {
+    const diffTime = Math.abs(date2 - date1);
+    return Math.ceil(diffTime / (1000 * 60 * 60));
+  }
+
+  differenceInMinutes(date1, date2) {
+    const diffTime = Math.abs(date2 - date1);
+    return Math.ceil(diffTime / (1000 * 60));
+  }
+
+  isBefore(date1, date2) {
+    return date1 < date2;
+  }
+
+  isAfter(date1, date2) {
+    return date1 > date2;
+  }
+
+  isSameDay(date1, date2) {
+    return date1.toDateString() === date2.toDateString();
+  }
+}
+
+module.exports = new TimeConverterHelper();
+{{else}}
+const toUTC = (date) => {
+  return new Date(date.toUTCString());
+};
+
+const toLocal = (date, timeZone = 'UTC') => {
+  return new Date(date.toLocaleString('en-US', { timeZone }));
+};
+
+const format = (date, formatStr = 'YYYY-MM-DD HH:mm:ss') => {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  const hours = String(date.getHours()).padStart(2, '0');
+  const minutes = String(date.getMinutes()).padStart(2, '0');
+  const seconds = String(date.getSeconds()).padStart(2, '0');
+
+  return formatStr
+    .replace('YYYY', year)
+    .replace('MM', month)
+    .replace('DD', day)
+    .replace('HH', hours)
+    .replace('mm', minutes)
+    .replace('ss', seconds);
+};
+
+const addDays = (date, days) => {
+  const result = new Date(date);
+  result.setDate(result.getDate() + days);
+  return result;
+};
+
+const addHours = (date, hours) => {
+  const result = new Date(date);
+  result.setHours(result.getHours() + hours);
+  return result;
+};
+
+const addMinutes = (date, minutes) => {
+  const result = new Date(date);
+  result.setMinutes(result.getMinutes() + minutes);
+  return result;
+};
+
+const differenceInDays = (date1, date2) => {
+  const diffTime = Math.abs(date2 - date1);
+  return Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+};
+
+const differenceInHours = (date1, date2) => {
+  const diffTime = Math.abs(date2 - date1);
+  return Math.ceil(diffTime / (1000 * 60 * 60));
+};
+
+const differenceInMinutes = (date1, date2) => {
+  const diffTime = Math.abs(date2 - date1);
+  return Math.ceil(diffTime / (1000 * 60));
+};
+
+const isBefore = (date1, date2) => {
+  return date1 < date2;
+};
+
+const isAfter = (date1, date2) => {
+  return date1 > date2;
+};
+
+const isSameDay = (date1, date2) => {
+  return date1.toDateString() === date2.toDateString();
+};
+
+module.exports = {
+  toUTC,
+  toLocal,
+  format,
+  addDays,
+  addHours,
+  addMinutes,
+  differenceInDays,
+  differenceInHours,
+  differenceInMinutes,
+  isBefore,
+  isAfter,
+  isSameDay
+};
+{{/if}}
+

package/src/templates/middleware.template

@@ -0,0 +1,302 @@
+{{#if isClass}}
+class {{className}}Middleware {
+  constructor() {
+    this.name = '{{name}}';
+  }
+
+  {{#if isAuth}}
+  authenticate(req, res, next) {
+    try {
+      // TODO: Implement authentication logic
+      const token = req.headers.authorization?.split(' ')[1];
+      
+      if (!token) {
+        return res.status(401).json({ 
+          success: false, 
+          message: 'Authentication token required' 
+        });
+      }
+
+      // TODO: Verify token
+      // const decoded = jwt.verify(token, process.env.JWT_SECRET);
+      // req.user = decoded;
+      
+      next();
+    } catch (error) {
+      res.status(401).json({ 
+        success: false, 
+        message: 'Invalid or expired token' 
+      });
+    }
+  }
+
+  authorize(...roles) {
+    return (req, res, next) => {
+      try {
+        // TODO: Check if user has required role
+        // if (!roles.includes(req.user.role)) {
+        //   return res.status(403).json({ 
+        //     success: false, 
+        //     message: 'Insufficient permissions' 
+        //   });
+        // }
+        next();
+      } catch (error) {
+        res.status(403).json({ 
+          success: false, 
+          message: 'Authorization failed' 
+        });
+      }
+    };
+  }
+  {{/if}}
+
+  {{#if isValidation}}
+  validate(validationSchema) {
+    return (req, res, next) => {
+      try {
+        // TODO: Implement validation using Joi/Yup
+        // const { error, value } = validationSchema.validate(req.body);
+        // if (error) {
+        //   return res.status(400).json({
+        //     success: false,
+        //     message: 'Validation error',
+        //     errors: error.details.map(detail => detail.message)
+        //   });
+        // }
+        // req.validatedData = value;
+        next();
+      } catch (error) {
+        res.status(400).json({
+          success: false,
+          message: 'Validation failed',
+          error: error.message
+        });
+      }
+    };
+  }
+  {{/if}}
+
+  {{#if isErrorHandler}}
+  errorHandler(err, req, res, next) {
+    console.error('Error:', err);
+
+    // Default error
+    let statusCode = err.statusCode || 500;
+    let message = err.message || 'Internal server error';
+
+    // Handle specific error types
+    if (err.name === 'ValidationError') {
+      statusCode = 400;
+      message = 'Validation error';
+    } else if (err.name === 'UnauthorizedError') {
+      statusCode = 401;
+      message = 'Unauthorized';
+    } else if (err.name === 'CastError') {
+      statusCode = 400;
+      message = 'Invalid ID format';
+    }
+
+    res.status(statusCode).json({
+      success: false,
+      message: message,
+      ...(process.env.NODE_ENV === 'development' && { stack: err.stack })
+    });
+  }
+
+  notFound(req, res, next) {
+    res.status(404).json({
+      success: false,
+      message: `Route ${req.originalUrl} not found`
+    });
+  }
+  {{/if}}
+
+  {{#if isRateLimit}}
+  rateLimiter(windowMs = 15 * 60 * 1000, max = 100) {
+    const requests = new Map();
+
+    return (req, res, next) => {
+      const ip = req.ip || req.connection.remoteAddress;
+      const now = Date.now();
+      
+      if (!requests.has(ip)) {
+        requests.set(ip, { count: 1, resetTime: now + windowMs });
+        return next();
+      }
+
+      const record = requests.get(ip);
+      
+      if (now > record.resetTime) {
+        record.count = 1;
+        record.resetTime = now + windowMs;
+        return next();
+      }
+
+      if (record.count >= max) {
+        return res.status(429).json({
+          success: false,
+          message: 'Too many requests, please try again later'
+        });
+      }
+
+      record.count++;
+      next();
+    };
+  }
+  {{/if}}
+}
+
+module.exports = new {{className}}Middleware();
+{{else}}
+{{#if isAuth}}
+const authenticate = (req, res, next) => {
+  try {
+    // TODO: Implement authentication logic
+    const token = req.headers.authorization?.split(' ')[1];
+    
+    if (!token) {
+      return res.status(401).json({ 
+        success: false, 
+        message: 'Authentication token required' 
+      });
+    }
+
+    // TODO: Verify token
+    // const decoded = jwt.verify(token, process.env.JWT_SECRET);
+    // req.user = decoded;
+    
+    next();
+  } catch (error) {
+    res.status(401).json({ 
+      success: false, 
+      message: 'Invalid or expired token' 
+    });
+  }
+};
+
+const authorize = (...roles) => {
+  return (req, res, next) => {
+    try {
+      // TODO: Check if user has required role
+      // if (!roles.includes(req.user.role)) {
+      //   return res.status(403).json({ 
+      //     success: false, 
+      //     message: 'Insufficient permissions' 
+      //   });
+      // }
+      next();
+    } catch (error) {
+      res.status(403).json({ 
+        success: false, 
+        message: 'Authorization failed' 
+      });
+    }
+  };
+};
+
+module.exports = { authenticate, authorize };
+{{/if}}
+
+{{#if isValidation}}
+const validate = (validationSchema) => {
+  return (req, res, next) => {
+    try {
+      // TODO: Implement validation using Joi/Yup
+      // const { error, value } = validationSchema.validate(req.body);
+      // if (error) {
+      //   return res.status(400).json({
+      //     success: false,
+      //     message: 'Validation error',
+      //     errors: error.details.map(detail => detail.message)
+      //   });
+      // }
+      // req.validatedData = value;
+      next();
+    } catch (error) {
+      res.status(400).json({
+        success: false,
+        message: 'Validation failed',
+        error: error.message
+      });
+    }
+  };
+};
+
+module.exports = { validate };
+{{/if}}
+
+{{#if isErrorHandler}}
+const errorHandler = (err, req, res, next) => {
+  console.error('Error:', err);
+
+  // Default error
+  let statusCode = err.statusCode || 500;
+  let message = err.message || 'Internal server error';
+
+  // Handle specific error types
+  if (err.name === 'ValidationError') {
+    statusCode = 400;
+    message = 'Validation error';
+  } else if (err.name === 'UnauthorizedError') {
+    statusCode = 401;
+    message = 'Unauthorized';
+  } else if (err.name === 'CastError') {
+    statusCode = 400;
+    message = 'Invalid ID format';
+  }
+
+  res.status(statusCode).json({
+    success: false,
+    message: message,
+    ...(process.env.NODE_ENV === 'development' && { stack: err.stack })
+  });
+};
+
+const notFound = (req, res, next) => {
+  res.status(404).json({
+    success: false,
+    message: `Route ${req.originalUrl} not found`
+  });
+};
+
+module.exports = { errorHandler, notFound };
+{{/if}}
+
+{{#if isRateLimit}}
+const rateLimiter = (windowMs = 15 * 60 * 1000, max = 100) => {
+  const requests = new Map();
+
+  return (req, res, next) => {
+    const ip = req.ip || req.connection.remoteAddress;
+    const now = Date.now();
+    
+    if (!requests.has(ip)) {
+      requests.set(ip, { count: 1, resetTime: now + windowMs });
+      return next();
+    }
+
+    const record = requests.get(ip);
+    
+    if (now > record.resetTime) {
+      record.count = 1;
+      record.resetTime = now + windowMs;
+      return next();
+    }
+
+    if (record.count >= max) {
+      return res.status(429).json({
+        success: false,
+        message: 'Too many requests, please try again later'
+      });
+    }
+
+    record.count++;
+    next();
+  };
+};
+
+module.exports = { rateLimiter };
+{{/if}}
+{{/if}}
+

package/src/templates/route.template

@@ -0,0 +1,56 @@
+{{#if isClass}}
+const express = require('express');
+const {{camelCaseName}}Controller = require('../controllers/{{name}}.controller');
+
+class {{className}}Routes {
+  constructor() {
+    this.router = express.Router();
+    this.setupRoutes();
+  }
+
+  setupRoutes() {
+    // GET /api/{{name}}s - Get all {{name}}s
+    this.router.get('/', {{camelCaseName}}Controller.getAll);
+
+    // GET /api/{{name}}s/:id - Get {{name}} by ID
+    this.router.get('/:id', {{camelCaseName}}Controller.getById);
+
+    // POST /api/{{name}}s - Create new {{name}}
+    this.router.post('/', {{camelCaseName}}Controller.create);
+
+    // PUT /api/{{name}}s/:id - Update {{name}}
+    this.router.put('/:id', {{camelCaseName}}Controller.update);
+
+    // DELETE /api/{{name}}s/:id - Delete {{name}}
+    this.router.delete('/:id', {{camelCaseName}}Controller.remove);
+  }
+
+  getRouter() {
+    return this.router;
+  }
+}
+
+module.exports = new {{className}}Routes().getRouter();
+{{else}}
+const express = require('express');
+const router = express.Router();
+const {{camelCaseName}}Controller = require('../controllers/{{name}}.controller');
+
+// GET /api/{{name}}s - Get all {{name}}s
+router.get('/', {{camelCaseName}}Controller.getAll);
+
+// GET /api/{{name}}s/:id - Get {{name}} by ID
+router.get('/:id', {{camelCaseName}}Controller.getById);
+
+// POST /api/{{name}}s - Create new {{name}}
+router.post('/', {{camelCaseName}}Controller.create);
+
+// PUT /api/{{name}}s/:id - Update {{name}}
+router.put('/:id', {{camelCaseName}}Controller.update);
+
+// DELETE /api/{{name}}s/:id - Delete {{name}}
+router.delete('/:id', {{camelCaseName}}Controller.remove);
+
+module.exports = router;
+{{/if}}
+