offbyt 1.0.0

package/templates/chat.routes.template.js

@@ -0,0 +1,478 @@
+/**
+ * Chat Routes Template
+ * REST API endpoints for chat functionality
+ */
+
+export const chatRoutesTemplate = `import express from 'express';
+import Message from '../models/Message.js';
+import Conversation from '../models/Conversation.js';
+import { authenticateToken } from '../middleware/auth.js';
+
+const router = express.Router();
+
+// All routes require authentication
+router.use(authenticateToken);
+
+// ============ CONVERSATIONS ============
+
+/**
+ * GET /api/chat/conversations
+ * Get all conversations for current user
+ */
+router.get('/conversations', async (req, res) => {
+  try {
+    const conversations = await Conversation.findByUser(req.user.id)
+      .populate('participants', 'name email avatar')
+      .populate({
+        path: 'lastMessage',
+        populate: { path: 'sender', select: 'name email' }
+      })
+      .lean();
+
+    res.json({
+      success: true,
+      count: conversations.length,
+      data: conversations
+    });
+  } catch (error) {
+    console.error('Get conversations error:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to fetch conversations'
+    });
+  }
+});
+
+/**
+ * GET /api/chat/conversations/:id
+ * Get single conversation details
+ */
+router.get('/conversations/:id', async (req, res) => {
+  try {
+    const conversation = await Conversation.findOne({
+      _id: req.params.id,
+      participants: req.user.id
+    })
+      .populate('participants', 'name email avatar')
+      .populate('admins', 'name email')
+      .lean();
+
+    if (!conversation) {
+      return res.status(404).json({
+        success: false,
+        message: 'Conversation not found'
+      });
+    }
+
+    res.json({
+      success: true,
+      data: conversation
+    });
+  } catch (error) {
+    console.error('Get conversation error:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to fetch conversation'
+    });
+  }
+});
+
+/**
+ * POST /api/chat/conversations
+ * Create new conversation
+ */
+router.post('/conversations', async (req, res) => {
+  try {
+    const { participantIds, name, type = 'direct' } = req.body;
+
+    if (!participantIds || !Array.isArray(participantIds)) {
+      return res.status(400).json({
+        success: false,
+        message: 'participantIds array is required'
+      });
+    }
+
+    // Include current user
+    const participants = [req.user.id, ...participantIds];
+
+    // For direct chats, check if exists
+    if (type === 'direct' && participants.length === 2) {
+      const existing = await Conversation.findDirectConversation(
+        participants[0],
+        participants[1]
+      );
+
+      if (existing) {
+        return res.json({
+          success: true,
+          data: existing,
+          isExisting: true
+        });
+      }
+    }
+
+    // Create new conversation
+    const conversation = await Conversation.create({
+      name,
+      type,
+      participants,
+      createdBy: req.user.id,
+      admins: type === 'group' ? [req.user.id] : []
+    });
+
+    await conversation.populate('participants', 'name email avatar');
+
+    res.status(201).json({
+      success: true,
+      data: conversation
+    });
+  } catch (error) {
+    console.error('Create conversation error:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to create conversation'
+    });
+  }
+});
+
+/**
+ * PUT /api/chat/conversations/:id
+ * Update conversation (name, settings, etc.)
+ */
+router.put('/conversations/:id', async (req, res) => {
+  try {
+    const conversation = await Conversation.findOne({
+      _id: req.params.id,
+      participants: req.user.id
+    });
+
+    if (!conversation) {
+      return res.status(404).json({
+        success: false,
+        message: 'Conversation not found'
+      });
+    }
+
+    // Only admins can update group conversations
+    if (conversation.type === 'group' && !conversation.isAdmin(req.user.id)) {
+      return res.status(403).json({
+        success: false,
+        message: 'Only admins can update group conversations'
+      });
+    }
+
+    const { name, description, avatar, settings } = req.body;
+
+    if (name) conversation.name = name;
+    if (description) conversation.description = description;
+    if (avatar) conversation.avatar = avatar;
+    if (settings) conversation.settings = { ...conversation.settings, ...settings };
+
+    await conversation.save();
+
+    res.json({
+      success: true,
+      data: conversation
+    });
+  } catch (error) {
+    console.error('Update conversation error:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to update conversation'
+    });
+  }
+});
+
+/**
+ * DELETE /api/chat/conversations/:id
+ * Delete/leave conversation
+ */
+router.delete('/conversations/:id', async (req, res) => {
+  try {
+    const conversation = await Conversation.findOne({
+      _id: req.params.id,
+      participants: req.user.id
+    });
+
+    if (!conversation) {
+      return res.status(404).json({
+        success: false,
+        message: 'Conversation not found'
+      });
+    }
+
+    // For direct chats, just remove the user
+    if (conversation.type === 'direct') {
+      await conversation.removeParticipant(req.user.id);
+    } else {
+      // For groups, if creator, delete. Otherwise, just leave.
+      if (conversation.createdBy.toString() === req.user.id) {
+        conversation.isActive = false;
+        await conversation.save();
+      } else {
+        await conversation.removeParticipant(req.user.id);
+      }
+    }
+
+    res.json({
+      success: true,
+      message: 'Left conversation successfully'
+    });
+  } catch (error) {
+    console.error('Delete conversation error:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to delete conversation'
+    });
+  }
+});
+
+// ============ MESSAGES ============
+
+/**
+ * GET /api/chat/conversations/:id/messages
+ * Get messages for a conversation
+ */
+router.get('/conversations/:id/messages', async (req, res) => {
+  try {
+    const { limit = 50, before, after } = req.query;
+
+    // Verify access
+    const conversation = await Conversation.findOne({
+      _id: req.params.id,
+      participants: req.user.id
+    });
+
+    if (!conversation) {
+      return res.status(404).json({
+        success: false,
+        message: 'Conversation not found'
+      });
+    }
+
+    const query = { 
+      conversation: req.params.id,
+      isDeleted: false
+    };
+
+    if (before) {
+      query.timestamp = { $lt: new Date(before) };
+    }
+
+    if (after) {
+      query.timestamp = { $gt: new Date(after) };
+    }
+
+    const messages = await Message.find(query)
+      .sort({ timestamp: -1 })
+      .limit(parseInt(limit))
+      .populate('sender', 'name email avatar')
+      .populate('replyTo', 'content sender')
+      .lean();
+
+    res.json({
+      success: true,
+      count: messages.length,
+      data: messages.reverse(),
+      hasMore: messages.length === parseInt(limit)
+    });
+  } catch (error) {
+    console.error('Get messages error:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to fetch messages'
+    });
+  }
+});
+
+/**
+ * POST /api/chat/conversations/:id/messages
+ * Send message (REST fallback - prefer Socket.io)
+ */
+router.post('/conversations/:id/messages', async (req, res) => {
+  try {
+    const { content, type = 'text', metadata } = req.body;
+
+    if (!content) {
+      return res.status(400).json({
+        success: false,
+        message: 'Content is required'
+      });
+    }
+
+    // Verify access
+    const conversation = await Conversation.findOne({
+      _id: req.params.id,
+      participants: req.user.id
+    });
+
+    if (!conversation) {
+      return res.status(404).json({
+        success: false,
+        message: 'Conversation not found'
+      });
+    }
+
+    const message = await Message.create({
+      conversation: req.params.id,
+      sender: req.user.id,
+      content,
+      type,
+      metadata
+    });
+
+    await message.populate('sender', 'name email avatar');
+
+    // Update conversation
+    conversation.lastMessage = message._id;
+    conversation.lastMessageAt = new Date();
+    await conversation.save();
+
+    res.status(201).json({
+      success: true,
+      data: message
+    });
+  } catch (error) {
+    console.error('Send message error:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to send message'
+    });
+  }
+});
+
+/**
+ * PUT /api/chat/messages/:id
+ * Edit message
+ */
+router.put('/messages/:id', async (req, res) => {
+  try {
+    const { content } = req.body;
+
+    const message = await Message.findOne({
+      _id: req.params.id,
+      sender: req.user.id
+    });
+
+    if (!message) {
+      return res.status(404).json({
+        success: false,
+        message: 'Message not found or not authorized'
+      });
+    }
+
+    message.content = content;
+    message.isEdited = true;
+    message.editedAt = new Date();
+    await message.save();
+
+    res.json({
+      success: true,
+      data: message
+    });
+  } catch (error) {
+    console.error('Edit message error:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to edit message'
+    });
+  }
+});
+
+/**
+ * DELETE /api/chat/messages/:id
+ * Delete message
+ */
+router.delete('/messages/:id', async (req, res) => {
+  try {
+    const message = await Message.findOne({
+      _id: req.params.id,
+      sender: req.user.id
+    });
+
+    if (!message) {
+      return res.status(404).json({
+        success: false,
+        message: 'Message not found or not authorized'
+      });
+    }
+
+    message.isDeleted = true;
+    message.deletedAt = new Date();
+    message.content = '[Message deleted]';
+    await message.save();
+
+    res.json({
+      success: true,
+      message: 'Message deleted successfully'
+    });
+  } catch (error) {
+    console.error('Delete message error:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to delete message'
+    });
+  }
+});
+
+/**
+ * POST /api/chat/messages/:id/reactions
+ * Add reaction to message
+ */
+router.post('/messages/:id/reactions', async (req, res) => {
+  try {
+    const { emoji } = req.body;
+
+    if (!emoji) {
+      return res.status(400).json({
+        success: false,
+        message: 'Emoji is required'
+      });
+    }
+
+    const message = await Message.findById(req.params.id);
+
+    if (!message) {
+      return res.status(404).json({
+        success: false,
+        message: 'Message not found'
+      });
+    }
+
+    // Check if user already reacted with this emoji
+    const existingReaction = message.reactions.find(
+      r => r.user.toString() === req.user.id && r.emoji === emoji
+    );
+
+    if (existingReaction) {
+      return res.status(400).json({
+        success: false,
+        message: 'Already reacted with this emoji'
+      });
+    }
+
+    message.reactions.push({
+      user: req.user.id,
+      emoji,
+      createdAt: new Date()
+    });
+
+    await message.save();
+
+    res.json({
+      success: true,
+      data: message
+    });
+  } catch (error) {
+    console.error('Add reaction error:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to add reaction'
+    });
+  }
+});
+
+export default router;
+`;
+
+export default chatRoutesTemplate;

package/templates/compression.middleware.js

@@ -0,0 +1,19 @@
+/**
+ * Compression Middleware
+ * Compresses response bodies for all requests that match the filter function
+ */
+
+import compression from 'compression';
+
+export const compressionMiddleware = compression({
+  filter: (req, res) => {
+    if (req.headers['x-no-compression']) {
+      return false;
+    }
+    return compression.filter(req, res);
+  },
+  level: process.env.NODE_ENV === 'production' ? 6 : 3,
+  threshold: 1024 // Only compress responses larger than 1KB
+});
+
+export default compressionMiddleware;

package/templates/database.config.js

@@ -0,0 +1,74 @@
+/**
+ * Database Configuration
+ * Centralized database connection and configuration
+ */
+
+import mongoose from 'mongoose';
+import chalk from 'chalk';
+
+const MONGODB_URI = process.env.MONGODB_URI || 'mongodb://localhost:27017/offbyt_app';
+
+export const dbConfig = {
+  uri: MONGODB_URI,
+  options: {
+    useNewUrlParser: true,
+    useUnifiedTopology: true,
+    maxPoolSize: 10,
+    minPoolSize: 5,
+    serverSelectionTimeoutMS: 5000,
+    socketTimeoutMS: 45000,
+    retryWrites: true,
+    retryReads: true
+  }
+};
+
+// Connection flags
+let isConnected = false;
+
+export async function connectDatabase() {
+  if (isConnected) {
+    return;
+  }
+
+  try {
+    await mongoose.connect(dbConfig.uri, dbConfig.options);
+    isConnected = true;
+    
+    mongoose.connection.on('error', (error) => {
+      console.error(chalk.red('❌ MongoDB Error:'), error.message);
+      isConnected = false;
+    });
+
+    mongoose.connection.on('disconnected', () => {
+      console.warn(chalk.yellow('⚠️  MongoDB Disconnected'));
+      isConnected = false;
+    });
+
+    console.log(chalk.green('✅ MongoDB Connected Successfully'));
+    return mongoose.connection;
+  } catch (error) {
+    console.error(chalk.red('❌ MongoDB Connection Failed:'), error.message);
+    throw error;
+  }
+}
+
+export async function disconnectDatabase() {
+  if (!isConnected) {
+    return;
+  }
+
+  try {
+    await mongoose.disconnect();
+    isConnected = false;
+    console.log(chalk.yellow('🔌 MongoDB Disconnected'));
+  } catch (error) {
+    console.error(chalk.red('❌ MongoDB Disconnection Error:'), error.message);
+  }
+}
+
+export function isDatabaseConnected() {
+  return isConnected && mongoose.connection.readyState === 1;
+}
+
+export default { connectDatabase, disconnectDatabase, isDatabaseConnected, dbConfig };
+

package/templates/errorHandler.middleware.js

@@ -0,0 +1,54 @@
+// Error Handler Middleware
+const errorHandler = (err, req, res, next) => {
+  console.error('❌ Error:', err.message);
+
+  // Mongoose Validation Error
+  if (err.name === 'ValidationError') {
+    return res.status(400).json({
+      success: false,
+      error: 'Validation Error',
+      details: Object.values(err.errors).map(e => e.message)
+    });
+  }
+
+  // Mongoose Cast Error
+  if (err.name === 'CastError') {
+    return res.status(400).json({
+      success: false,
+      error: 'Invalid ID format'
+    });
+  }
+
+  // Duplicate Key Error
+  if (err.code === 11000) {
+    const field = Object.keys(err.keyPattern)[0];
+    return res.status(409).json({
+      success: false,
+      error: `${field} already exists`
+    });
+  }
+
+  // JWT Errors
+  if (err.name === 'JsonWebTokenError') {
+    return res.status(401).json({
+      success: false,
+      error: 'Invalid token'
+    });
+  }
+
+  if (err.name === 'TokenExpiredError') {
+    return res.status(401).json({
+      success: false,
+      error: 'Token expired'
+    });
+  }
+
+  // Default Error
+  res.status(err.statusCode || 500).json({
+    success: false,
+    error: err.message || 'Internal Server Error',
+    ...(process.env.NODE_ENV === 'development' && { stack: err.stack })
+  });
+};
+
+export default errorHandler;

package/templates/express/controller.ejs

@@ -0,0 +1,26 @@
+import <%= modelName %> from '../models/<%= modelName %>.js';
+
+export const list<%= modelNamePlural %> = async (req, res) => {
+  const data = await <%= modelName %>.find();
+  res.json({ success: true, data });
+};
+
+export const get<%= modelName %> = async (req, res) => {
+  const data = await <%= modelName %>.findById(req.params.id);
+  res.json({ success: true, data });
+};
+
+export const create<%= modelName %> = async (req, res) => {
+  const data = await <%= modelName %>.create(req.body);
+  res.status(201).json({ success: true, data });
+};
+
+export const update<%= modelName %> = async (req, res) => {
+  const data = await <%= modelName %>.findByIdAndUpdate(req.params.id, req.body, { new: true });
+  res.json({ success: true, data });
+};
+
+export const delete<%= modelName %> = async (req, res) => {
+  await <%= modelName %>.findByIdAndDelete(req.params.id);
+  res.json({ success: true });
+};

package/templates/express/model.ejs

@@ -0,0 +1,9 @@
+import mongoose from 'mongoose';
+
+const <%= modelVar %>Schema = new mongoose.Schema({
+<% fields.forEach(function(field) { %>
+  <%= field.name %>: { type: <%= field.type %><%= field.required ? ', required: true' : '' %> },
+<% }); %>
+}, { timestamps: true });
+
+export default mongoose.model('<%= modelName %>', <%= modelVar %>Schema);

package/templates/express/route.ejs

@@ -0,0 +1,18 @@
+import express from 'express';
+import {
+  list<%= modelNamePlural %>,
+  get<%= modelName %>,
+  create<%= modelName %>,
+  update<%= modelName %>,
+  delete<%= modelName %>
+} from '../controllers/<%= resourceName %>Controller.js';
+
+const router = express.Router();
+
+router.get('/', list<%= modelNamePlural %>);
+router.get('/:id', get<%= modelName %>);
+router.post('/', create<%= modelName %>);
+router.put('/:id', update<%= modelName %>);
+router.delete('/:id', delete<%= modelName %>);
+
+export default router;

package/templates/express/server.ejs

@@ -0,0 +1,16 @@
+import express from 'express';
+import cors from 'cors';
+<% resources.forEach(function(r) { %>import <%= r.name %>Routes from './src/routes/<%= r.name %>.routes.js';
+<% }); %>
+
+const app = express();
+app.use(cors());
+app.use(express.json());
+
+<% resources.forEach(function(r) { %>app.use('/api/<%= r.name %>s', <%= r.name %>Routes);
+<% }); %>
+
+app.get('/health', (req, res) => res.json({ status: 'ok' }));
+
+const PORT = process.env.PORT || 3000;
+app.listen(PORT, () => console.log(`Server running on ${PORT}`));

package/templates/frontend.env.template

@@ -0,0 +1,14 @@
+# ========== FRONTEND ENVIRONMENT VARIABLES ==========
+# Copy this file as .env in your frontend root directory
+
+# API Configuration
+# NOTE: Should NOT include /api path - backend will handle route prefixing
+VITE_API_URL=http://localhost:5000
+
+# App Configuration
+VITE_APP_NAME=YourAppName
+VITE_APP_VERSION=1.0.0
+
+# Optional: Features
+VITE_ENABLE_ANALYTICS=false
+VITE_ENABLE_LOGGING=true