offbyt 1.0.0

package/lib/generator/irBasedGenerator.js

@@ -0,0 +1,360 @@
+/**
+ * IR-Based Generator
+ * Main orchestrator: Scanner → IR → Templates → Generated Code
+ *
+ * This is the professional approach used by Yeoman, create-react-app, etc.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { buildIR, validateIR, printIR } from '../ir-builder/irBuilder.js';
+import { renderTemplate } from '../ir-builder/templateEngine.js';
+import { MODEL_TEMPLATE } from '../ir-builder/templates/model.template.js';
+import { ROUTES_USER_TEMPLATE } from '../ir-builder/templates/routes-user.template.js';
+import { ROUTES_GENERIC_TEMPLATE } from '../ir-builder/templates/routes-generic.template.js';
+import { VALIDATION_TEMPLATE } from '../ir-builder/templates/validation.template.js';
+
+/**
+ * Main entry point: Generate complete backend from scanner output
+ * 
+ * Usage:
+ * const generated = await generateBackendFromScanner(detectedApis, options);
+ */
+export async function generateBackendFromScanner(detectedApis, options = {}) {
+  try {
+    console.log('🔄 Starting IR-based generation pipeline...\n');
+
+    // Step 1: Build IR
+    console.log('📊 Step 1: Building Intermediate Representation (IR)...');
+    const ir = buildIR(detectedApis, options);
+
+    // 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');
+    }
+    console.log('✅ IR built successfully');
+    console.log(`   Resources: ${ir.resources.map(r => r.name).join(', ')}\n`);
+
+    // Step 2: Generate code for each resource
+    console.log('🔨 Step 2: Generating code from templates...');
+    const generated = {};
+
+    for (const resource of ir.resources) {
+      console.log(`   Generating ${resource.name}...`);
+
+      // Use user routes template for users, generic for others
+      const routesTemplate = resource.name === 'user' ? ROUTES_USER_TEMPLATE : ROUTES_GENERIC_TEMPLATE;
+
+      generated[resource.name] = {
+        model: renderTemplate(MODEL_TEMPLATE, ir, resource.name),
+        routes: resource.name === 'user' ? routesTemplate : renderTemplate(routesTemplate, ir, resource.name),
+        validation: renderTemplate(VALIDATION_TEMPLATE, ir, resource.name),
+        ir: JSON.stringify(ir, null, 2)
+      };
+    }
+
+    console.log(`✅ Generated ${ir.resources.length} models, routes, and validators\n`);
+
+    // Step 3: Return complete structure
+    return {
+      success: true,
+      ir,
+      generated,
+      resources: ir.resources,
+      metadata: {
+        totalResources: ir.resources.length,
+        totalEndpoints: ir.resources.reduce((sum, r) => sum + r.endpoints.length, 0),
+        timestamp: new Date().toISOString()
+      }
+    };
+  } catch (error) {
+    console.error(`❌ Generation failed: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Write generated files to disk
+ */
+export async function writeGeneratedFiles(generated, outputDir, projectType = 'express') {
+  try {
+    console.log(`\n📁 Writing files to ${outputDir}...\n`);
+
+    // Create directory structure
+    const dirs = [
+      `${outputDir}/models`,
+      `${outputDir}/routes`,
+      `${outputDir}/validations`,
+      `${outputDir}/ir-schemas`
+    ];
+
+    for (const dir of dirs) {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+        console.log(`   📂 Created ${path.relative(process.cwd(), dir)}`);
+      }
+    }
+
+    // Write files
+    let fileCount = 0;
+
+    for (const [resourceName, code] of Object.entries(generated)) {
+      if (typeof code === 'object') {
+        // Model
+        const modelPath = `${outputDir}/models/${capitalize(resourceName)}.model.js`;
+        fs.writeFileSync(modelPath, code.model);
+        console.log(`   ✅ ${path.relative(process.cwd(), modelPath)}`);
+        fileCount++;
+
+        // Routes
+        const routesPath = `${outputDir}/routes/${resourceName}.routes.js`;
+        fs.writeFileSync(routesPath, code.routes);
+        console.log(`   ✅ ${path.relative(process.cwd(), routesPath)}`);
+        fileCount++;
+
+        // Validation
+        const validationPath = `${outputDir}/validations/${resourceName}.validation.js`;
+        fs.writeFileSync(validationPath, code.validation);
+        console.log(`   ✅ ${path.relative(process.cwd(), validationPath)}`);
+        fileCount++;
+
+        // IR Schema (for reference)
+        const schemaPath = `${outputDir}/ir-schemas/${resourceName}.ir.json`;
+        fs.writeFileSync(schemaPath, code.ir);
+        fileCount++;
+      }
+    }
+
+    console.log(`\n✅ Generated ${fileCount} files successfully!\n`);
+    return { success: true, filesWritten: fileCount };
+  } catch (error) {
+    console.error(`❌ Failed to write files: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Generate complete backend structure (scaffold)
+ */
+export async function generateBackendScaffold(ir, outputDir) {
+  const scaffoldFiles = {
+    'server.js': generateServerFile(ir),
+    'package.json': generatePackageJson(ir),
+    '.env.example': generateEnvFile(ir),
+    'config/db.js': generateDbConfig(ir),
+    'middleware/errorHandler.js': generateErrorHandler(),
+    'middleware/requestLogger.js': generateRequestLogger()
+  };
+
+  console.log('\n🏗️  Creating backend scaffold...\n');
+
+  for (const [filePath, content] of Object.entries(scaffoldFiles)) {
+    const fullPath = `${outputDir}/${filePath}`;
+    const dir = path.dirname(fullPath);
+
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    fs.writeFileSync(fullPath, content);
+    console.log(`   ✅ ${path.relative(process.cwd(), fullPath)}`);
+  }
+
+  console.log('\n✅ Backend scaffold created!\n');
+}
+
+/**
+ * Helper: Generate server.js
+ */
+function generateServerFile(ir) {
+  const imports = ir.resources
+    .map(r => `import ${capitalize(r.singular)}Routes from './routes/${r.name}.routes.js';`)
+    .join('\n');
+
+  const mountRoutes = ir.resources
+    .map(r => `app.use('/api/${r.plural}', ${capitalize(r.singular)}Routes);`)
+    .join('\n');
+
+  return `import express from 'express';
+import cors from 'cors';
+import mongoose from 'mongoose';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const app = express();
+
+// Middleware
+app.use(express.json());
+app.use(cors());
+
+// Connect to MongoDB
+mongoose.connect(process.env.MONGODB_URI)
+  .then(() => console.log('✅ Connected to MongoDB'))
+  .catch(err => console.error('❌ MongoDB connection failed:', err));
+
+// Routes
+${imports}
+
+${mountRoutes}
+
+// Error handling
+app.use((err, req, res, next) => {
+  console.error(err.stack);
+  res.status(err.status || 500).json({
+    success: false,
+    error: err.message
+  });
+});
+
+const PORT = process.env.PORT || 3000;
+app.listen(PORT, () => {
+  console.log(\`🚀 Server running on port \${PORT}\`);
+});
+`;
+}
+
+/**
+ * Helper: Generate package.json
+ */
+function generatePackageJson(ir) {
+  const pkg = {
+    name: 'offbyt-generated',
+    version: '1.0.0',
+    type: 'module',
+    scripts: {
+      start: 'node server.js',
+      dev: 'nodemon server.js',
+      test: 'echo "Error: no test specified" && exit 1'
+    },
+    dependencies: {
+      express: '^4.18.0',
+      mongoose: '^8.0.0',
+      cors: '^2.8.5',
+      dotenv: '^16.3.1',
+      joi: '^17.11.0'
+    },
+    devDependencies: {
+      nodemon: '^3.0.1'
+    }
+  };
+
+  return JSON.stringify(pkg, null, 2);
+}
+
+/**
+ * Helper: Generate .env file
+ */
+function generateEnvFile(ir) {
+  return `# Database
+MONGODB_URI=mongodb://localhost:27017/offbyt-${ir.settings.apiVersion}
+
+# Server
+PORT=3000
+NODE_ENV=development
+
+# API
+API_VERSION=${ir.settings.apiVersion || 'v1'}
+
+# Auth (if needed)
+JWT_SECRET=your-secret-key-here
+`;
+}
+
+/**
+ * Helper: Generate database config
+ */
+function generateDbConfig(ir) {
+  return `import mongoose from 'mongoose';
+
+const connectDB = async () => {
+  try {
+    await mongoose.connect(process.env.MONGODB_URI, {
+      useNewUrlParser: true,
+      useUnifiedTopology: true,
+    });
+    console.log('✅ MongoDB connected');
+  } catch (error) {
+    console.error('❌ MongoDB connection failed:', error);
+    process.exit(1);
+  }
+};
+
+export default connectDB;
+`;
+}
+
+/**
+ * Helper: Generate error handler
+ */
+function generateErrorHandler() {
+  return `export const errorHandler = (err, req, res, next) => {
+  const status = err.status || 500;
+  const message = err.message || 'Internal Server Error';
+
+  console.error(\`[\${new Date().toISOString()}] \${status} - \${message}\`);
+
+  res.status(status).json({
+    success: false,
+    status,
+    error: message,
+    ...(process.env.NODE_ENV === 'development' && { stack: err.stack })
+  });
+};
+`;
+}
+
+/**
+ * Helper: Generate request logger
+ */
+function generateRequestLogger() {
+  return `export const requestLogger = (req, res, next) => {
+  const start = Date.now();
+
+  res.on('finish', () => {
+    const duration = Date.now() - start;
+    console.log(
+      \`[\${new Date().toISOString()}] \${req.method} \${req.path} - \${res.statusCode} (\${duration}ms)\`
+    );
+  });
+
+  next();
+};
+`;
+}
+
+/**
+ * Helper: Capitalize
+ */
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+/**
+ * Print generation summary
+ */
+export function printGenerationSummary(result) {
+  console.log('\n' + '='.repeat(60));
+  console.log('🎉 BACKEND GENERATION COMPLETE!');
+  console.log('='.repeat(60));
+  console.log(`\n📊 Generated Resources:`);
+
+  result.resources.forEach(resource => {
+    console.log(`\n   ${capitalize(resource.singular)}:`);
+    console.log(`     • Model: ${resource.name}.model.js`);
+    console.log(`     • Routes: ${resource.name}.routes.js`);
+    console.log(`     • Validation: ${resource.name}.validation.js`);
+    console.log(`     • Fields: ${resource.fields.map(f => f.name).join(', ')}`);
+    console.log(`     • Endpoints: ${resource.endpoints.map(e => `${e.method} ${e.path}`).join(', ')}`);
+  });
+
+  console.log(`\n📈 Statistics:`);
+  console.log(`   • Total Resources: ${result.metadata.totalResources}`);
+  console.log(`   • Total Endpoints: ${result.metadata.totalEndpoints}`);
+  console.log(`   • Generated At: ${result.metadata.timestamp}`);
+  console.log('\n' + '='.repeat(60) + '\n');
+}
+

package/lib/ir-builder/index.js

@@ -0,0 +1,16 @@
+/**
+ * IR Builder - Main Export
+ * Complete IR generation pipeline
+ */
+
+export { buildIR, validateIR, printIR } from './irBuilder.js';
+export {
+  detectFieldType,
+  buildFieldConfig,
+  shouldIndex,
+  detectRelationship,
+  getAllRules,
+  addCustomRule,
+  getRule
+} from './rulesEngine.js';
+export { renderTemplate, renderAllTemplates, validateTemplate } from './templateEngine.js';

package/lib/ir-builder/irBuilder.js

@@ -0,0 +1,330 @@
+/**
+ * IR Builder - Converts Scanner Output to Intermediate Representation
+ * Creates structured, language-agnostic description of backend
+ */
+
+import { buildFieldConfig, detectRelationship } from './rulesEngine.js';
+
+/**
+ * Build IR from scanner detected APIs
+ * @param {Array} detectedApis - Output from scanner
+ * @param {Object} options - Configuration options
+ * @returns {Object} - Complete IR
+ */
+export function buildIR(detectedApis = [], options = {}) {
+  const resources = [];
+  const relationships = [];
+  const globalSettings = {
+    hasAuth: options.hasAuth || false,
+    dbType: options.dbType || 'mongodb',
+    apiVersion: options.apiVersion || 'v1',
+    ...options
+  };
+
+  // Group APIs by resource
+  const resourceMap = groupApisByResource(detectedApis);
+
+  // PASS 1: Build basic resource info (names only)
+  const resourceNames = [];
+  for (const resourceName of Object.keys(resourceMap)) {
+    const normalized = normalizeResourceName(resourceName);
+    resourceNames.push({
+      name: normalized,
+      singular: singularize(resourceName),
+      plural: pluralize(resourceName)
+    });
+  }
+
+  // PASS 2: Build complete resource definitions with smart relationship detection
+  for (const [resourceName, apis] of Object.entries(resourceMap)) {
+    const resource = buildResourceIR(resourceName, apis, options, resourceNames);
+    resources.push(resource);
+
+    // Track relationships
+    resource.fields.forEach(field => {
+      if (field.relationship) {
+        relationships.push({
+          from: resource.name,
+          to: field.relationship.ref,
+          field: field.name,
+          type: 'reference'
+        });
+      }
+    });
+  }
+
+  return {
+    version: '1.0',
+    metadata: {
+      createdAt: new Date().toISOString(),
+      generator: 'offbyt-ir-builder'
+    },
+    settings: globalSettings,
+    resources,
+    relationships,
+    hooks: generateHooks(resources)
+  };
+}
+
+/**
+ * Build single resource IR
+ */
+function buildResourceIR(resourceName, apis, options, resourceNames = []) {
+  const methods = new Set(apis.map(api => api.method));
+  
+  // Infer fields from API documentation or use defaults
+  // Pass resourceNames so relationship detection can work
+  const fields = inferFieldsFromApis(apis, options, resourceNames);
+
+  // Add audit fields if auth enabled
+  if (options.hasAuth) {
+    if (!fields.find(f => f.name === 'userId')) {
+      fields.push({
+        name: 'userId',
+        type: 'ObjectId',
+        ref: 'User',
+        isRequired: true,
+        relationship: { ref: 'User' }
+      });
+    }
+  }
+
+  return {
+    name: normalizeResourceName(resourceName),
+    singular: singularize(resourceName),
+    plural: pluralize(resourceName),
+    description: `${capitalizeFirst(resourceName)} resource`,
+    fields,
+    routes: Array.from(methods),
+    endpoints: apis.map(api => ({
+      method: api.method,
+      path: api.path,
+      action: inferAction(api)
+    })),
+    validations: generateValidations(fields),
+    middleware: generateMiddleware(fields, options),
+    timestamps: true
+  };
+}
+
+/**
+ * Group APIs by resource name
+ */
+function groupApisByResource(apis) {
+  const grouped = {};
+
+  for (const api of apis) {
+    let resource = null;
+
+    // First check if api object has resource property explicitly
+    if (api.resource) {
+      resource = api.resource;
+    } else {
+      // Extract resource from path
+      // Handle both /api/users and /api/v1/users patterns
+      let match = api.path.match(/\/api\/(?:v\d+\/)?(\w+)/);
+      if (match) {
+        resource = match[1];
+      }
+    }
+
+    if (resource) {
+      if (!grouped[resource]) grouped[resource] = [];
+      grouped[resource].push(api);
+    }
+  }
+
+  return grouped;
+}
+
+/**
+ * Infer fields from APIs (or use smart defaults)
+ */
+function inferFieldsFromApis(apis, options, resourceNames = []) {
+  const fields = [];
+  const fieldSet = new Set();
+
+  // Get common field names for this resource
+  const commonFields = getCommonFieldsForResource(apis[0]?.path);
+
+  for (const fieldName of commonFields) {
+    if (!fieldSet.has(fieldName)) {
+      const config = buildFieldConfig(fieldName, '', resourceNames);
+      fields.push(config);
+      fieldSet.add(fieldName);
+    }
+  }
+
+  return fields;
+}
+
+/**
+ * Get smart default fields for resource based on type
+ * Enhanced with automatic relationship fields
+ */
+function getCommonFieldsForResource(apiPath) {
+  // Smart defaults based on resource type with relationship fields
+  const defaults = {
+    users: ['username', 'firstName', 'lastName', 'email', 'password', 'phone', 'avatar', 'bio', 'role', 'active'],
+    products: ['name', 'description', 'price', 'category', 'stock', 'image', 'rating', 'seller'],
+    posts: ['title', 'content', 'author', 'tags', 'published', 'views', 'likes'],
+    comments: ['text', 'author', 'post', 'likes', 'approved'],
+    categories: ['name', 'description', 'parent', 'active'],
+    events: ['title', 'description', 'club', 'date', 'location', 'capacity', 'organizer', 'image'],
+    clubs: ['name', 'description', 'admin', 'members', 'image'],
+    registrations: ['event', 'user', 'status'],
+    orders: ['items', 'total', 'status', 'user', 'deliveryAddress', 'paymentStatus'],
+    reviews: ['rating', 'text', 'author', 'product', 'verified']
+  };
+
+  // Try to match resource type from API path
+  for (const [type, fields] of Object.entries(defaults)) {
+    if (apiPath?.includes(`/${type}`)) {
+      return fields;
+    }
+  }
+
+  // Default fields for any resource
+  return ['name', 'description', 'active'];
+}
+
+/**
+ * Infer action from API endpoint
+ */
+function inferAction(api) {
+  const methodToAction = {
+    'GET': 'read',
+    'POST': 'create',
+    'PUT': 'update',
+    'PATCH': 'update',
+    'DELETE': 'delete'
+  };
+
+  return methodToAction[api.method] || 'custom';
+}
+
+/**
+ * Generate validation rules from fields
+ */
+function generateValidations(fields) {
+  const validations = {};
+
+  for (const field of fields) {
+    const fieldValidations = [];
+
+    if (field.isRequired) fieldValidations.push('required');
+    if (field.validators) fieldValidations.push(...field.validators);
+
+    if (fieldValidations.length > 0) {
+      validations[field.name] = fieldValidations;
+    }
+  }
+
+  return validations;
+}
+
+/**
+ * Generate required middleware based on fields
+ */
+function generateMiddleware(fields, options) {
+  const middleware = [];
+
+  // Add auth middleware if needed
+  if (options.hasAuth) {
+    middleware.push('authenticate');
+  }
+
+  // Add validation middleware
+  middleware.push('validateInput');
+
+  // Add error handling
+  middleware.push('errorHandler');
+
+  return middleware;
+}
+
+/**
+ * Generate hooks needed for fields
+ */
+function generateHooks(resources) {
+  const hooks = {};
+
+  for (const resource of resources) {
+    hooks[resource.name] = [];
+
+    for (const field of resource.fields) {
+      if (field.hooks) {
+        hooks[resource.name].push(...field.hooks);
+      }
+    }
+
+    // Remove duplicates
+    hooks[resource.name] = [...new Set(hooks[resource.name])];
+  }
+
+  return hooks;
+}
+
+/**
+ * Helper: Normalize resource name
+ */
+function normalizeResourceName(name) {
+  return name.toLowerCase().replace(/s$/, '').replace(/ies$/, 'y');
+}
+
+/**
+ * Helper: Singularize
+ */
+function singularize(word) {
+  if (word.endsWith('ies')) return word.slice(0, -3) + 'y';
+  if (word.endsWith('s')) return word.slice(0, -1);
+  return word;
+}
+
+/**
+ * Helper: Pluralize
+ */
+function pluralize(word) {
+  if (word.endsWith('y')) return word.slice(0, -1) + 'ies';
+  return word + 's';
+}
+
+/**
+ * Helper: Capitalize first letter
+ */
+function capitalizeFirst(word) {
+  return word.charAt(0).toUpperCase() + word.slice(1);
+}
+
+/**
+ * Validate IR structure
+ */
+export function validateIR(ir) {
+  const errors = [];
+
+  if (!ir.version) errors.push('Missing IR version');
+  if (!ir.resources || !Array.isArray(ir.resources)) {
+    errors.push('Missing or invalid resources array');
+  }
+  if (!ir.settings) errors.push('Missing settings');
+
+  ir.resources?.forEach((resource, idx) => {
+    if (!resource.name) errors.push(`Resource ${idx} missing name`);
+    if (!resource.fields || !Array.isArray(resource.fields)) {
+      errors.push(`Resource ${resource.name} missing fields`);
+    }
+  });
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+/**
+ * Pretty print IR (for debugging)
+ */
+export function printIR(ir) {
+  return JSON.stringify(ir, null, 2);
+}
+