offbyt 1.0.0

package/lib/ir-builder/templates/routes-user.template.js

@@ -0,0 +1,105 @@
+/**
+ * User Routes Template - With Auth
+ */
+
+export const ROUTES_USER_TEMPLATE = `import express from 'express';
+import User from '../models/User.model.js';
+import bcryptjs from 'bcryptjs';
+import jwt from 'jsonwebtoken';
+
+const router = express.Router();
+const JWT_SECRET = process.env.JWT_SECRET || 'dev-secret-key';
+const JWT_EXPIRE = process.env.JWT_EXPIRE || process.env.JWT_EXPIRES_IN || '7d';
+
+// POST signup
+router.post('/signup', async (req, res) => {
+  try {
+    const { username, email, password, firstName, lastName, role } = req.body;
+    const existing = await User.findOne({ email });
+    if (existing) return res.status(400).json({ success: false, error: 'Email already registered' });
+    const hashedPassword = await bcryptjs.hash(password, 10);
+    const userRole = role || 'student';
+    const data = new User({ username, email, password: hashedPassword, firstName, lastName, role: userRole });
+    await data.save();
+    const token = jwt.sign({ id: data._id, email: data.email }, JWT_SECRET, { expiresIn: JWT_EXPIRE });
+    res.status(201).json({ success: true, message: 'User created', data: { id: data._id, email: data.email, firstName: data.firstName, lastName: data.lastName, role: userRole }, token });
+  } catch (error) {
+    res.status(400).json({ success: false, error: error.message });
+  }
+});
+
+// POST login
+router.post('/login', async (req, res) => {
+  try {
+    const { email, password } = req.body;
+    const user = await User.findOne({ email });
+    if (!user) return res.status(401).json({ success: false, error: 'Invalid credentials' });
+    const isValid = await bcryptjs.compare(password, user.password);
+    if (!isValid) return res.status(401).json({ success: false, error: 'Invalid credentials' });
+    const token = jwt.sign({ id: user._id, email: user.email }, JWT_SECRET, { expiresIn: JWT_EXPIRE });
+    res.json({ success: true, message: 'Login successful', data: { id: user._id, email: user.email, firstName: user.firstName, lastName: user.lastName, role: user.role }, token });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// GET all users
+router.get('/', async (req, res) => {
+  try {
+    const { skip = 0, limit = 100 } = req.query;
+    const data = await User.find({ isDeleted: false }).skip(parseInt(skip)).limit(parseInt(limit));
+    const total = await User.countDocuments({ isDeleted: false });
+    res.json({ success: true, data, total, skip: parseInt(skip), limit: parseInt(limit) });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// GET single user
+router.get('/:id', async (req, res) => {
+  try {
+    const data = await User.findById(req.params.id);
+    if (!data) return res.status(404).json({ success: false, error: 'Not found' });
+    res.json({ success: true, data });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// POST create user
+router.post('/', async (req, res) => {
+  try {
+    const data = new User(req.body);
+    if (data.password) {
+      data.password = await bcryptjs.hash(data.password, 10);
+    }
+    await data.save();
+    res.status(201).json({ success: true, data, message: 'Created successfully' });
+  } catch (error) {
+    res.status(400).json({ success: false, error: error.message });
+  }
+});
+
+// PUT update user
+router.put('/:id', async (req, res) => {
+  try {
+    const data = await User.findByIdAndUpdate(req.params.id, req.body, { new: true });
+    if (!data) return res.status(404).json({ success: false, error: 'Not found' });
+    res.json({ success: true, data, message: 'Updated successfully' });
+  } catch (error) {
+    res.status(400).json({ success: false, error: error.message });
+  }
+});
+
+// DELETE user
+router.delete('/:id', async (req, res) => {
+  try {
+    await User.findByIdAndUpdate(req.params.id, { isDeleted: true });
+    res.json({ success: true, message: 'Deleted successfully' });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+export default router;
+`;

package/lib/ir-builder/templates/routes.template.js

@@ -0,0 +1,102 @@
+/**
+ * Express Routes Template
+ */
+
+export const ROUTES_TEMPLATE = `import express from 'express';
+import <%= capitalize(resource.singular) %> from '../models/<%= capitalize(resource.singular) %>.model.js';
+import bcryptjs from 'bcryptjs';
+import jwt from 'jsonwebtoken';
+
+const router = express.Router();
+const JWT_SECRET = process.env.JWT_SECRET || 'dev-secret-key';
+const JWT_EXPIRE = process.env.JWT_EXPIRE || process.env.JWT_EXPIRES_IN || '7d';
+
+// POST signup (for users resource only)
+router.post('/signup', async (req, res) => {
+  try {
+    const { username, email, password, firstName, lastName } = req.body;
+    const existing = await <%= capitalize(resource.singular) %>.findOne({ email });
+    if (existing) return res.status(400).json({ success: false, error: 'Email already registered' });
+    const hashedPassword = await bcryptjs.hash(password, 10);
+    const data = new <%= capitalize(resource.singular) %>({ username, email, password: hashedPassword, firstName, lastName, role: 'student' });
+    await data.save();
+    const token = jwt.sign({ id: data._id, email: data.email }, JWT_SECRET, { expiresIn: JWT_EXPIRE });
+    res.status(201).json({ success: true, message: 'User created', data: { id: data._id, email: data.email, firstName: data.firstName, lastName: data.lastName }, token });
+  } catch (error) {
+    res.status(400).json({ success: false, error: error.message });
+  }
+});
+
+// POST login (for users resource only)
+router.post('/login', async (req, res) => {
+  try {
+    const { email, password } = req.body;
+    const user = await <%= capitalize(resource.singular) %>.findOne({ email });
+    if (!user) return res.status(401).json({ success: false, error: 'Invalid credentials' });
+    const isValid = await bcryptjs.compare(password, user.password);
+    if (!isValid) return res.status(401).json({ success: false, error: 'Invalid credentials' });
+    const token = jwt.sign({ id: user._id, email: user.email }, JWT_SECRET, { expiresIn: JWT_EXPIRE });
+    res.json({ success: true, message: 'Login successful', data: { id: user._id, email: user.email, firstName: user.firstName, lastName: user.lastName }, token });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// GET all <%= resource.plural %>
+router.get('/', async (req, res) => {
+  try {
+    const { skip = 0, limit = 100 } = req.query;
+    const data = await <%= capitalize(resource.singular) %>.find({ isDeleted: false }).skip(parseInt(skip)).limit(parseInt(limit)).populate('user').populate('event').populate('club').populate('organizer').populate('admin').populate('members');
+    const total = await <%= capitalize(resource.singular) %>.countDocuments({ isDeleted: false });
+    res.json({ success: true, data, total, skip: parseInt(skip), limit: parseInt(limit) });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// GET single <%= resource.singular %>
+router.get('/:id', async (req, res) => {
+  try {
+    const data = await <%= capitalize(resource.singular) %>.findById(req.params.id).populate('user').populate('event').populate('club').populate('organizer').populate('admin').populate('members');
+    if (!data) return res.status(404).json({ success: false, error: 'Not found' });
+    res.json({ success: true, data });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// POST create <%= resource.singular %>
+router.post('/', async (req, res) => {
+  try {
+    const data = new <%= capitalize(resource.singular) %>(req.body);
+    await data.save();
+    await data.populate('user').populate('event').populate('club').populate('organizer').populate('admin').populate('members');
+    res.status(201).json({ success: true, data, message: 'Created successfully' });
+  } catch (error) {
+    res.status(400).json({ success: false, error: error.message });
+  }
+});
+
+// PUT update <%= resource.singular %>
+router.put('/:id', async (req, res) => {
+  try {
+    const data = await <%= capitalize(resource.singular) %>.findByIdAndUpdate(req.params.id, req.body, { new: true }).populate('user').populate('event').populate('club').populate('organizer').populate('admin').populate('members');
+    if (!data) return res.status(404).json({ success: false, error: 'Not found' });
+    res.json({ success: true, data, message: 'Updated successfully' });
+  } catch (error) {
+    res.status(400).json({ success: false, error: error.message });
+  }
+});
+
+// DELETE <%= resource.singular %>
+router.delete('/:id', async (req, res) => {
+  try {
+    await <%= capitalize(resource.singular) %>.findByIdAndUpdate(req.params.id, { isDeleted: true });
+    res.json({ success: true, message: 'Deleted successfully' });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+export default router;
+`;

package/lib/ir-builder/templates/validation.template.js

@@ -0,0 +1,15 @@
+/**
+ * Validation Schema Template
+ */
+
+export const VALIDATION_TEMPLATE = `import Joi from 'joi';
+
+const validate<%= capitalize(resource.singular) %> = {
+  create: Joi.object({
+    name: Joi.string().required(),
+    email: Joi.string().email().optional()
+  })
+};
+
+export default validate<%= capitalize(resource.singular) %>;
+`;

package/lib/ir-integration.js

@@ -0,0 +1,349 @@
+/**
+ * IR Integration - Connects Scanner → IR → Generator
+ * 
+ * Professional pipeline: Scan → Build IR → Generate Code
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { scanFrontendCode } from './scanner/frontendScanner.js';
+import { buildIR, validateIR, printIR } from './ir-builder/irBuilder.js';
+import {
+  generateBackendFromScanner,
+  writeGeneratedFiles,
+  generateBackendScaffold,
+  printGenerationSummary
+} from './generator/irBasedGenerator.js';
+
+/**
+ * Complete pipeline: Frontend → IR → Backend
+ */
+export async function offbyteWithIR(frontendPath, outputPath, options = {}) {
+  console.log('\n' + '='.repeat(70));
+  console.log('🚀 offbyt - IR-Based Backend Generation');
+  console.log('='.repeat(70) + '\n');
+
+  try {
+    // Step 1: Scan frontend
+    console.log('📱 STEP 1: Scanning Frontend Code\n');
+    const detectedApis = scanFrontendCode(frontendPath);
+    
+    if (detectedApis.length === 0) {
+      console.warn('⚠️  No APIs detected. Make sure frontend has API calls.');
+      return;
+    }
+
+    console.log(`✅ Detected ${detectedApis.length} API calls\n`);
+
+    // Step 2: Save detected APIs
+    const apisPath = path.join(outputPath, 'detected-apis.json');
+    if (!fs.existsSync(path.dirname(apisPath))) {
+      fs.mkdirSync(path.dirname(apisPath), { recursive: true });
+    }
+    fs.writeFileSync(apisPath, JSON.stringify(detectedApis, null, 2));
+    console.log(`💾 Saved API detections to: detectedapis.json\n`);
+
+    // Step 3: Build IR
+    console.log('🧠 STEP 2: Building Intermediate Representation (IR)\n');
+    const ir = buildIR(detectedApis, {
+      hasAuth: options.hasAuth ?? true,
+      dbType: options.dbType ?? 'mongodb',
+      apiVersion: options.apiVersion ?? 'v1',
+      projectName: options.projectName || path.basename(frontendPath)
+    });
+
+    // Validate IR
+    const validation = validateIR(ir);
+    if (!validation.valid) {
+      console.error('❌ IR Validation Failed:');
+      validation.errors.forEach(err => console.error(`   - ${err}`));
+      throw new Error('Invalid IR structure');
+    }
+
+    // Save IR
+    const irPath = path.join(outputPath, 'project.ir.json');
+    fs.writeFileSync(irPath, JSON.stringify(ir, null, 2));
+    console.log(`💾 Saved IR to: project.ir.json`);
+
+    console.log(`✅ IR built with ${ir.resources.length} resources\n`);
+
+    // Step 4: Generate backend
+    console.log('🔨 STEP 3: Generating Backend Code\n');
+    const result = await generateBackendFromScanner(detectedApis, {
+      hasAuth: options.hasAuth ?? true,
+      dbType: options.dbType ?? 'mongodb'
+    });
+
+    // Step 5: Write files
+    console.log('📁 STEP 4: Writing Generated Files\n');
+    
+    // Create models, routes, validations
+    const backendDir = path.join(outputPath, 'generated');
+    await writeGeneratedFiles(result.generated, backendDir);
+
+    // Create scaffold (server.js, package.json, etc.)
+    await generateBackendScaffold(result.ir, backendDir);
+
+    // Create README
+    createReadme(backendDir, ir, options);
+
+    // Step 6: Summary
+    printGenerationSummary(result);
+
+    // Additional info
+    console.log('📊 IR Structure Breakdown:\n');
+    ir.resources.forEach(resource => {
+      console.log(`   📦 ${resource.singular}:`);
+      console.log(`      Fields: ${resource.fields.map(f => f.name).join(', ')}`);
+      console.log(`      Routes: ${resource.routes.join(', ')}`);
+      if (resource.validations && Object.keys(resource.validations).length > 0) {
+        console.log(`      Validations: ${Object.keys(resource.validations).join(', ')}`);
+      }
+    });
+
+    console.log('\n' + '='.repeat(70));
+    console.log('✨ GENERATION COMPLETE!');
+    console.log('='.repeat(70) + '\n');
+
+    console.log('📂 Generated Structure:');
+    console.log(`   ${backendDir}/`);
+    console.log(`   ├── models/          (Mongoose models)`);
+    console.log(`   ├── routes/          (Express routes)`);
+    console.log(`   ├── validations/     (Input validators)`);
+    console.log(`   ├── middleware/      (Middleware handlers)`);
+    console.log(`   ├── config/          (Database config)`);
+    console.log(`   ├── server.js        (Express server)`);
+    console.log(`   ├── package.json     (Dependencies)`);
+    console.log(`   ├── .env.example     (Environment variables)`);
+    console.log(`   ├── README.md        (Documentation)`);
+    console.log(`   └── ir-schemas/      (IR JSON files)\n`);
+
+    console.log('🚀 Next Steps:');
+    console.log(`   1. cd ${backendDir}`);
+    console.log(`   2. npm install`);
+    console.log(`   3. Configure .env file`);
+    console.log(`   4. npm run dev\n`);
+
+    return {
+      success: true,
+      ir,
+      generatedDir: backendDir,
+      stats: {
+        resourcesGenerated: ir.resources.length,
+        endpointsGenerated: ir.resources.reduce((sum, r) => sum + r.endpoints.length, 0),
+        fieldsDefinedGenerated: ir.resources.reduce((sum, r) => sum + r.fields.length, 0)
+      }
+    };
+
+  } catch (error) {
+    console.error('\n❌ Generation Failed:');
+    console.error(`   ${error.message}\n`);
+    throw error;
+  }
+}
+
+/**
+ * Create README for generated project
+ */
+function createReadme(outputDir, ir, options) {
+  const resources = ir.resources.map(r => 
+    `- **${r.singular}** (\`${r.plural}\`): ${r.fields.map(f => f.name).join(', ')}`
+  ).join('\n');
+
+  const readme = `# Generated Backend
+
+Auto-generated with **offbyt IR Architecture**
+
+Generated on: ${new Date().toLocaleString()}
+
+## 📦 Resources
+
+${resources}
+
+## 🚀 Getting Started
+
+\`\`\`bash
+npm install
+\`\`\`
+
+### Configuration
+
+Create a \`.env\` file (copy from \`.env.example\`):
+
+\`\`\`env
+MONGODB_URI=mongodb://localhost:27017/offbyt-${ir.settings.apiVersion}
+PORT=3000
+NODE_ENV=development
+JWT_SECRET=your-secret-key
+\`\`\`
+
+### Development
+
+\`\`\`bash
+npm run dev
+\`\`\`
+
+Server will start on \`http://localhost:3000\`
+
+## 📚 API Documentation
+
+### Base URL
+
+\`/api/${ir.settings.apiVersion}\`
+
+### Endpoints
+
+${ir.resources.map(r => {
+  const endpoints = r.endpoints.map(e => {
+    const method = e.method;
+    const path = `/api/` + r.plural + (method === 'GET' && e.path.includes(':id') ? '/:id' : '');
+    return '- `' + method + ' ' + path + '`';
+  }).join('\n');
+  return '#### ' + r.singular + '\n\n' + endpoints;
+}).join('\n\n')}
+
+## 🔒 Authentication
+
+${ir.settings.hasAuth ? 'Authentication is enabled. Include JWT token in Authorization header.' : 'No authentication configured.'}
+
+## 📂 Project Structure
+
+\`\`\`
+.
+├── models/          Mongoose schemas
+├── routes/          Express route handlers  
+├── validations/     Input validation schemas
+├── middleware/      Custom middleware
+├── config/          Database & environment config
+├── server.js        Express server entry point
+└── package.json     Dependencies
+\`\`\`
+
+## 🔧 Customization
+
+Generated files are ready for customization:
+
+1. **Add Business Logic**: Edit files in \`models/\` and \`routes/\`
+2. **Extend Validation**: Modify validation files
+3. **Add Middleware**: Create new middleware in \`middleware/\`
+4. **Database Hooks**: Add Mongoose hooks in model files
+
+## 🧪 Testing
+
+\`\`\`bash
+npm test
+\`\`\`
+
+## 📝 Environment Variables
+
+See \`.env.example\` for all configuration options.
+
+## 🚀 Deployment
+
+### Using Docker
+
+Create \`Dockerfile\`:
+
+\`\`\`dockerfile
+FROM node:18-alpine
+
+WORKDIR /app
+
+COPY package*.json ./
+RUN npm ci --only=production
+
+COPY . .
+
+EXPOSE 3000
+CMD ["npm", "start"]
+\`\`\`
+
+Build and run:
+
+\`\`\`bash
+docker build -t offbyt-app .
+docker run -p 3000:3000 offbyt-app
+\`\`\`
+
+### Using Node.js
+
+\`\`\`bash
+npm install
+NODE_ENV=production npm start
+\`\`\`
+
+## 📊 Tech Stack
+
+- **Runtime**: Node.js 18+
+- **Framework**: Express.js
+- **Database**: MongoDB + Mongoose
+- **Validation**: Joi
+- **Logger**: Built-in request logger
+
+## 📄 License
+
+Generated by offbyt IR Architecture
+
+---
+
+**Generated by**: offbyt  
+**Generation Date**: ${new Date().toISOString()}  
+**IR Version**: ${ir.version}
+`;
+
+  const readmePath = path.join(outputDir, 'README.md');
+  fs.writeFileSync(readmePath, readme);
+  console.log(`   ✅ ${path.relative(process.cwd(), readmePath)}`);
+}
+
+/**
+ * Quick start: Directory → Full Backend
+ */
+export async function quickGenerate(frontendPath, options = {}) {
+  const projectName = path.basename(frontendPath);
+  const outputPath = `./offbyt-${projectName}`;
+
+  return offbyteWithIR(frontendPath, outputPath, {
+    projectName,
+    ...options
+  });
+}
+
+/**
+ * CLI Helper
+ */
+export async function runFromCLI(args) {
+  const [command, frontendPath, outputPath] = args;
+
+  if (!frontendPath) {
+    console.log('\n📖 Usage: node ir-integration.js <frontend-path> [output-path]\n');
+    console.log('Examples:');
+    console.log('  node ir-integration.js ./my-app');
+    console.log('  node ir-integration.js ./frontend ./generated-backend\n');
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(frontendPath)) {
+    console.error(`❌ Frontend path not found: ${frontendPath}`);
+    process.exit(1);
+  }
+
+  const out = outputPath || `./offbyt-${path.basename(frontendPath)}`;
+
+  try {
+    await offbyteWithIR(frontendPath, out, {
+      hasAuth: true,
+      projectName: path.basename(frontendPath)
+    });
+  } catch (error) {
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runFromCLI(process.argv.slice(2));
+}
+
+export default offbyteWithIR;
+