offbyt 1.0.0

package/lib/ir-builder/rulesEngine.js

@@ -0,0 +1,353 @@
+/**
+ * Rules Engine - Field Detection & Type Resolution
+ * Professional approach: Rules define how to detect & validate fields
+ * NOT hardcoded if/else logic
+ */
+
+/**
+ * Core Rules - What defines each field type
+ * Pattern: fieldNamePattern → fieldType + validators + properties
+ */
+const FIELD_RULES = {
+  // Email Field
+  email: {
+    patterns: ['email', 'emailaddress', 'e-mail', 'user_email'],
+    type: 'String',
+    properties: {
+      lowercase: true,
+      trim: true,
+      match: '/.+\\@.+\\..+/'
+    },
+    validators: ['email', 'required'],
+    description: 'Email field with validation'
+  },
+
+  // Password Fields
+  password: {
+    patterns: ['password', 'passwd', 'pwd', 'confirmpassword', 'newpassword'],
+    type: 'String',
+    properties: {
+      select: false, // Don't return in queries
+      minlength: 6
+    },
+    validators: ['required', 'hash'],
+    hooks: ['hash-before-save'],
+    description: 'Password field - auto hashed'
+  },
+
+  // Phone Numbers
+  phone: {
+    patterns: ['phone', 'phonenumber', 'mobile', 'mobilenumber', 'contact'],
+    type: 'String',
+    properties: {
+      match: '/^\\d{10,}$/'
+    },
+    validators: ['phone'],
+    description: 'Phone number with validation'
+  },
+
+  // URLs
+  url: {
+    patterns: ['url', 'website', 'link', 'profileurl', 'avatar', 'image', 'photo'],
+    type: 'String',
+    properties: {
+      trim: true
+    },
+    validators: ['url'],
+    description: 'URL field with validation'
+  },
+
+  // Dates
+  date: {
+    patterns: ['date', 'createddate', 'duedate', 'deadline', 'startdate', 'enddate', 'publishdate', 'birthdate'],
+    type: 'Date',
+    properties: {},
+    validators: ['date'],
+    description: 'Date field'
+  },
+
+  // Boolean Fields
+  boolean: {
+    patterns: ['active', 'inactive', 'completed', 'published', 'verified', 'approved', 'enabled', 'disabled', 'public', 'private', 'is_', 'has_'],
+    type: 'Boolean',
+    properties: {
+      default: false
+    },
+    validators: [],
+    description: 'Boolean flag field'
+  },
+
+  // Numbers - Price/Cost
+  price: {
+    patterns: ['price', 'cost', 'amount', 'rate', 'salary', 'fee', 'charge', 'total'],
+    type: 'Number',
+    properties: {
+      default: 0,
+      min: 0
+    },
+    validators: ['number', 'positive'],
+    description: 'Monetary value'
+  },
+
+  // Numbers - Count/Rating
+  count: {
+    patterns: ['count', 'views', 'likes', 'downloads', 'rating', 'score', 'points', 'stars'],
+    type: 'Number',
+    properties: {
+      default: 0,
+      min: 0
+    },
+    validators: ['number'],
+    description: 'Numeric counter field'
+  },
+
+  // ID/Reference Fields
+  reference: {
+    patterns: ['id', 'userid', 'authorid', 'postid', 'productid', 'categoryid', 'ownerid', 'createdby', 'updatedby', '_id', 'ref_'],
+    type: 'ObjectId',
+    properties: {
+      ref: 'AUTO' // Ref determined by field name
+    },
+    validators: [],
+    hooks: ['resolve-reference'],
+    description: 'Reference to another document'
+  },
+
+  // Status Enum
+  status: {
+    patterns: ['status', 'state', 'condition'],
+    type: 'String',
+    properties: {
+      enum: ['active', 'inactive', 'pending', 'archived', 'deleted'],
+      default: 'active'
+    },
+    validators: ['enum'],
+    description: 'Status field with predefined values'
+  },
+
+  // Array of Strings
+  tags: {
+    patterns: ['tags', 'categories', 'keywords', 'labels', 'skills', 'interests'],
+    type: 'Array',
+    properties: {
+      itemType: 'String'
+    },
+    validators: ['array'],
+    description: 'List of string values'
+  },
+
+  // Rich Text/Markdown
+  text: {
+    patterns: ['description', 'content', 'body', 'bio', 'summary', 'intro', 'notes', 'remarks', 'feedback'],
+    type: 'String',
+    properties: {
+      trim: true
+    },
+    validators: ['text'],
+    description: 'Long text field'
+  },
+
+  // Default String
+  string: {
+    patterns: ['name', 'title', 'username', 'firstname', 'lastname', 'fullname', 'displayname'],
+    type: 'String',
+    properties: {
+      trim: true,
+      required: true
+    },
+    validators: ['required', 'string'],
+    description: 'Standard string field'
+  }
+};
+
+/**
+ * Apply rules to detect field type
+ * @param {string} fieldName - The field name from frontend
+ * @returns {Object} - Detected field configuration
+ */
+export function detectFieldType(fieldName) {
+  const normalizedName = fieldName.toLowerCase();
+
+  // Check each rule
+  for (const [ruleKey, rule] of Object.entries(FIELD_RULES)) {
+    // Check if field name matches any pattern
+    const matches = rule.patterns.some(pattern => {
+      if (pattern.startsWith('is_') || pattern.startsWith('has_')) {
+        return normalizedName.startsWith(pattern);
+      }
+      return normalizedName.includes(pattern);
+    });
+
+    if (matches) {
+      return {
+        fieldName,
+        rule: ruleKey,
+        type: rule.type,
+        properties: { ...rule.properties },
+        validators: [...rule.validators],
+        hooks: rule.hooks || [],
+        description: rule.description
+      };
+    }
+  }
+
+  // Default: treat as string
+  return {
+    fieldName,
+    rule: 'string',
+    type: 'String',
+    properties: { trim: true },
+    validators: ['string'],
+    hooks: [],
+    description: 'Default string field'
+  };
+}
+
+/**
+ * Detect if field needs indexing
+ * @param {string} fieldName
+ * @returns {boolean}
+ */
+export function shouldIndex(fieldName) {
+  const indexPatterns = ['email', 'username', 'userid', 'status', 'active', 'createdby'];
+  return indexPatterns.some(
+    pattern => fieldName.toLowerCase().includes(pattern)
+  );
+}
+
+/**
+ * Detect relationships between resources
+ * Enhanced to auto-detect common relationship patterns
+ * @param {string} fieldName
+ * @param {string} resourceName
+ * @param {Array} allResources - List of all available resources
+ * @returns {Object|null}
+ */
+export function detectRelationship(fieldName, resourceName, allResources = []) {
+  const normalized = fieldName.toLowerCase();
+  
+  // Smart role-based user references (admin, organizer, owner, creator, author)
+  const userRolePatterns = ['admin', 'organizer', 'owner', 'creator', 'author', 'user', 'createdby', 'updatedby', 'assignedto'];
+  for (const pattern of userRolePatterns) {
+    if (normalized === pattern || normalized.startsWith(pattern)) {
+      return {
+        fieldName,
+        type: 'ObjectId',
+        ref: 'User',
+        isRequired: ['admin', 'organizer', 'owner', 'creator', 'user'].includes(normalized)
+      };
+    }
+  }
+  
+  // Array of user references (members, participants, attendees, followers, subscribers, admins, organizers)
+  const userArrayPatterns = ['members', 'participants', 'attendees', 'followers', 'subscribers', 'admins', 'organizers', 'users', 'authors', 'contributors'];
+  if (userArrayPatterns.includes(normalized)) {
+    return {
+      fieldName,
+      type: 'Array',
+      arrayItemType: 'ObjectId',
+      ref: 'User',
+      isRequired: false
+    };
+  }
+
+  // Direct resource name references (club, event, product, category, etc.)
+  // Check if field name matches any resource name
+  const resourceMatch = allResources.find(r => 
+    normalized === r.name.toLowerCase() || 
+    normalized === r.singular.toLowerCase() ||
+    normalized === r.plural.toLowerCase()
+  );
+  
+  if (resourceMatch) {
+    // Check if it's plural (array) or singular (single ref)
+    const isArray = normalized === resourceMatch.plural.toLowerCase();
+    
+    return {
+      fieldName,
+      type: isArray ? 'Array' : 'ObjectId',
+      arrayItemType: isArray ? 'ObjectId' : undefined,
+      ref: resourceMatch.singular.charAt(0).toUpperCase() + resourceMatch.singular.slice(1),
+      isRequired: !isArray && ['club', 'event', 'product', 'category', 'post'].includes(normalized)
+    };
+  }
+
+  // UserId → Reference to User (existing pattern)
+  // ProductId → Reference to Product
+  // AuthorId → Reference to User
+  const idMatch = normalized.match(/(\w+)id$/i);
+  if (idMatch) {
+    let refModel = idMatch[1];
+    
+    // Smart mapping
+    const commonMappings = {
+      'author': 'User',
+      'user': 'User',
+      'owner': 'User',
+      'creator': 'User',
+      'admin': 'User',
+      'organizer': 'User'
+    };
+
+    refModel = commonMappings[refModel] || 
+               refModel.charAt(0).toUpperCase() + refModel.slice(1);
+
+    return {
+      fieldName,
+      type: 'ObjectId',
+      ref: refModel,
+      isRequired: false
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Build complete field configuration from rules
+ * @param {string} fieldName
+ * @param {string} resourceName
+ * @param {Array} allResources - List of all resources for relationship detection
+ * @returns {Object}
+ */
+export function buildFieldConfig(fieldName, resourceName = '', allResources = []) {
+  const detected = detectFieldType(fieldName);
+  const relationship = detectRelationship(fieldName, resourceName, allResources);
+
+  return {
+    name: fieldName,
+    ...detected,
+    relationship,
+    shouldIndex: shouldIndex(fieldName),
+    isRequired: 
+      fieldName.toLowerCase().includes('required') ||
+      fieldName.toLowerCase().includes('email') ||
+      fieldName.toLowerCase().includes('name') ||
+      (relationship && relationship.isRequired)
+  };
+}
+
+/**
+ * Get all rules (for rule engine UI/admin)
+ */
+export function getAllRules() {
+  return Object.entries(FIELD_RULES).map(([key, rule]) => ({
+    id: key,
+    ...rule
+  }));
+}
+
+/**
+ * Add custom rule (for extensibility)
+ */
+export function addCustomRule(identity, rule) {
+  FIELD_RULES[identity] = rule;
+  return true;
+}
+
+/**
+ * Get rule by ID
+ */
+export function getRule(ruleId) {
+  return FIELD_RULES[ruleId] || null;
+}

package/lib/ir-builder/templateEngine.js

@@ -0,0 +1,193 @@
+/**
+ * Template Engine - IR + Templates → Generated Code
+ * Uses simple but powerful template syntax
+ */
+
+/**
+ * Render template with IR data
+ * Supports: <%= %> for variables, <% %> for logic
+ */
+export function renderTemplate(template, ir, resourceName) {
+  if (!template) return '';
+
+  const resource = ir.resources.find(r => r.name === resourceName);
+  if (!resource) throw new Error(`Resource ${resourceName} not found in IR`);
+
+  // Create template context with helpers
+  const context = {
+    resource,
+    ir,
+    ...getTemplateHelpers()
+  };
+
+  // Simple template rendering
+  return compileTemplate(template, context);
+}
+
+/**
+ * Compile template with context
+ * Supports: <%= expression %>, <% code %>, <%# comment %>
+ */
+function compileTemplate(template, context) {
+  let result = template;
+
+  // Remove comments <%# ... %>
+  result = result.replace(/<%#[\s\S]*?%>/g, '');
+
+  // Process output blocks <%= ... %> FIRST (before code blocks)
+  result = result.replace(/<%=([\s\S]*?)%>/g, (match, expr) => {
+    try {
+      const trimmedExpr = expr.trim();
+      const func = new Function(...Object.keys(context), `return ${trimmedExpr}`);
+      const value = func(...Object.values(context));
+      return value ?? '';
+    } catch (e) {
+      console.warn(`Template expression error at: ${expr.substring(0, 50)}... - ${e.message}`);
+      return '';
+    }
+  });
+
+  // Process code blocks <% ... %> AFTER output blocks
+  result = result.replace(/<%(?!=)([\s\S]*?)%>/g, (match, code) => {
+    try {
+      // Create function with context access
+      const func = new Function(...Object.keys(context), code);
+      func(...Object.values(context));
+      return '';
+    } catch (e) {
+      console.warn(`Template code block error: ${e.message}`);
+      return '';
+    }
+  });
+
+  return result;
+}
+
+/**
+ * Template helper functions (available in templates)
+ */
+function getTemplateHelpers() {
+  return {
+    // String helpers
+    capitalize: (str) => str.charAt(0).toUpperCase() + str.slice(1),
+    camelCase: (str) => str.replace(/[-_](.)/g, (_, c) => c.toUpperCase()),
+    snakeCase: (str) => str.replace(/([A-Z])/g, '_$1').toLowerCase(),
+    kebabCase: (str) => str.replace(/([A-Z])/g, '-$1').toLowerCase(),
+
+    // Field helpers
+    fieldsByType: (fields, type) => fields.filter(f => f.type === type),
+    requiredFields: (fields) => fields.filter(f => f.isRequired),
+    indexedFields: (fields) => fields.filter(f => f.shouldIndex),
+    fieldsWithValidators: (fields) => fields.filter(f => f.validators?.length > 0),
+
+    // Array helpers
+    forEach: (items, callback) => items.map(callback).join(''),
+    join: (items, separator = ', ') => items.join(separator),
+
+    // Conditional - use 'conditional' instead of 'if' to avoid reserved keyword
+    conditional: (condition, trueValue, falseValue = '') => condition ? trueValue : falseValue,
+
+    // Field schema generator for Mongoose models
+    generateFieldSchema: (field) => {
+      let type = field.type === 'ObjectId' ? 'mongoose.Types.ObjectId' 
+        : field.type === 'Date' ? 'Date' 
+        : field.type === 'Number' ? 'Number' 
+        : field.type === 'Boolean' ? 'Boolean' 
+        : 'String';
+      let def = field.name + ': { type: ' + type;
+      if (field.type === 'ObjectId' && field.relationship) {
+        def += ", ref: '" + field.relationship.ref + "'";
+      }
+      if (field.isRequired) def += ', required: true';
+      if (field.shouldIndex) def += ', index: true';
+      def += ' }';
+      return def;
+    },
+
+    // Validation generator for Joi
+    generateJoiValidation: (field) => {
+      let type = field.type === 'ObjectId' ? 'string()'
+        : field.type === 'String' ? 'string()'
+        : field.type === 'Number' ? 'number()'
+        : field.type === 'Date' ? 'date()'
+        : field.type === 'Boolean' ? 'boolean()'
+        : 'string()';
+      let def = field.name + ': Joi.' + type;
+      if (field.isRequired) def += '.required()';
+      else def += '.optional()';
+      return def;
+    }
+  };
+}
+
+/**
+ * Batch render multiple templates (model, routes, etc.)
+ */
+export function renderAllTemplates(ir, templates) {
+  const generated = {};
+
+  for (const [templateName, template] of Object.entries(templates)) {
+    try {
+      for (const resource of ir.resources) {
+        const key = `${resource.name}.${templateName}`;
+        generated[key] = renderTemplate(template, ir, resource.name);
+      }
+    } catch (error) {
+      console.error(`Failed to render ${templateName}: ${error.message}`);
+    }
+  }
+
+  return generated;
+}
+
+/**
+ * Validate template syntax
+ */
+export function validateTemplate(template) {
+  const errors = [];
+
+  // Check for mismatched delimiters
+  const openTags = (template.match(/<%/g) || []).length;
+  const closeTags = (template.match(/%>/g) || []).length;
+  
+  if (openTags !== closeTags) {
+    errors.push(`Mismatched template tags: ${openTags} opening, ${closeTags} closing`);
+  }
+
+  // Try simple parse
+  try {
+    new Function('resource, ir', template);
+  } catch (e) {
+    errors.push(`Template syntax error: ${e.message}`);
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+/**
+ * Advanced: Iterator helper for templates
+ */
+export class TemplateIterator {
+  constructor(items) {
+    this.items = items;
+    this.index = 0;
+  }
+
+  each(callback) {
+    return this.items.map((item, i) => {
+      this.index = i;
+      return callback(item, i, this.items);
+    }).join('');
+  }
+
+  map(callback) {
+    return this.items.map(callback);
+  }
+
+  filter(predicate) {
+    return this.items.filter(predicate);
+  }
+}

package/lib/ir-builder/templates/index.js

@@ -0,0 +1,14 @@
+/**
+ * All IR-based Templates Export
+ */
+
+export { MODEL_TEMPLATE } from './model.template.js';
+export { ROUTES_TEMPLATE } from './routes.template.js';
+export { VALIDATION_TEMPLATE } from './validation.template.js';
+
+// Template map for easy access
+export const TEMPLATES = {
+  model: () => import('./model.template.js').then(m => m.MODEL_TEMPLATE),
+  routes: () => import('./routes.template.js').then(m => m.ROUTES_TEMPLATE),
+  validation: () => import('./validation.template.js').then(m => m.VALIDATION_TEMPLATE),
+};

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

@@ -0,0 +1,47 @@
+/**
+ * Mongoose Model Template
+ */
+
+export const MODEL_TEMPLATE = `import mongoose from 'mongoose';
+
+const <%= capitalize(resource.singular) %>Schema = new mongoose.Schema({
+  <%= resource.name === 'user' ? \`
+  username: { type: String, unique: true, sparse: true },
+  email: { type: String, unique: true, required: true },
+  password: { type: String, required: true },
+  firstName: { type: String },
+  lastName: { type: String },
+  role: { type: String, enum: ['student', 'organizer', 'admin'], default: 'student' },
+  avatar: { type: String },
+\` : resource.name === 'club' ? \`
+  name: { type: String, required: true },
+  description: { type: String },
+  admin: { type: mongoose.Types.ObjectId, ref: 'User', required: true },
+  members: [{ type: mongoose.Types.ObjectId, ref: 'User' }],
+  image: { type: String },
+\` : resource.name === 'event' ? \`
+  title: { type: String, required: true },
+  description: { type: String },
+  club: { type: mongoose.Types.ObjectId, ref: 'Club', required: true },
+  date: { type: Date, required: true },
+  location: { type: String },
+  capacity: { type: Number },
+  organizer: { type: mongoose.Types.ObjectId, ref: 'User' },
+  image: { type: String },
+\` : resource.name === 'registration' ? \`
+  event: { type: mongoose.Types.ObjectId, ref: 'Event', required: true },
+  user: { type: mongoose.Types.ObjectId, ref: 'User', required: true },
+  status: { type: String, enum: ['confirmed', 'waitlist', 'cancelled'], default: 'confirmed' },
+\` : \`
+  name: { type: String, required: true },
+  email: { type: String },
+\` %>
+  createdAt: { type: Date, default: Date.now },
+  updatedAt: { type: Date, default: Date.now },
+  isActive: { type: Boolean, default: true },
+  isDeleted: { type: Boolean, default: false }
+}, { timestamps: true, collection: '<%= resource.plural.toLowerCase() %>' });
+
+const <%= capitalize(resource.singular) %> = mongoose.model('<%= capitalize(resource.singular) %>', <%= capitalize(resource.singular) %>Schema);
+export default <%= capitalize(resource.singular) %>;
+`;

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

@@ -0,0 +1,66 @@
+/**
+ * Generic Resource Routes Template - CRUD only
+ */
+
+export const ROUTES_GENERIC_TEMPLATE = `import express from 'express';
+import <%= capitalize(resource.singular) %> from '../models/<%= capitalize(resource.singular) %>.model.js';
+
+const router = express.Router();
+
+// 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));
+    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);
+    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();
+    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 });
+    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;
+`;