voltjs-framework 1.0.0

package/src/cli/generate.js

@@ -0,0 +1,278 @@
+/**
+ * VoltJS CLI — `volt generate <type> <name>`
+ * Generate pages, API routes, components, models, middleware, migrations.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const c = {
+  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+  red: '\x1b[31m', green: '\x1b[32m', cyan: '\x1b[36m',
+};
+
+const generators = {
+  page(name, cwd) {
+    const filePath = path.join(cwd, 'pages', `${name}.js`);
+    const content = `/**
+ * Page: /${name}
+ * Auto-discovered by VoltJS file-based routing.
+ */
+
+module.exports = {
+  // GET /${name}
+  async get(req, res) {
+    res.render('${name}', {
+      title: '${capitalize(name)}',
+    });
+  },
+
+  // POST /${name}
+  // async post(req, res) {
+  //   res.json({ message: '${name} created' });
+  // },
+};
+`;
+    writeFile(filePath, content);
+
+    // Also create the view
+    const viewPath = path.join(cwd, 'views', `${name}.volt`);
+    if (!fs.existsSync(viewPath)) {
+      const viewContent = `{#layout layouts/main}
+
+{#block content}
+<div style="padding: 2rem; max-width: 800px; margin: 0 auto;">
+  <h1>{{ title }}</h1>
+  <p>This is the ${name} page.</p>
+</div>
+{/block}
+`;
+      writeFile(viewPath, viewContent);
+    }
+  },
+
+  api(name, cwd) {
+    const filePath = path.join(cwd, 'api', `${name}.js`);
+    const modelName = capitalize(singularize(name));
+    const content = `/**
+ * API: /api/${name}
+ * Auto-discovered by VoltJS.
+ */
+
+module.exports = {
+  // GET /api/${name}
+  async get(req, res) {
+    // const items = await ${modelName}.all();
+    res.json({ data: [], message: 'List ${name}' });
+  },
+
+  // POST /api/${name}
+  async post(req, res) {
+    // const item = await ${modelName}.create(req.body);
+    res.json({ data: req.body, message: '${modelName} created' }, 201);
+  },
+
+  // GET /api/${name}/:id
+  async show(req, res) {
+    const { id } = req.params;
+    // const item = await ${modelName}.find(id);
+    res.json({ data: { id }, message: '${modelName} details' });
+  },
+
+  // PUT /api/${name}/:id
+  async update(req, res) {
+    const { id } = req.params;
+    // const item = await ${modelName}.updateById(id, req.body);
+    res.json({ data: { id, ...req.body }, message: '${modelName} updated' });
+  },
+
+  // DELETE /api/${name}/:id
+  async destroy(req, res) {
+    const { id } = req.params;
+    // await ${modelName}.deleteById(id);
+    res.json({ message: '${modelName} deleted' });
+  },
+};
+`;
+    writeFile(filePath, content);
+  },
+
+  component(name, cwd) {
+    const filePath = path.join(cwd, 'components', `${name}.js`);
+    const className = capitalize(name);
+    const content = `const { Component } = require('voltjs');
+
+class ${className} extends Component {
+  setup() {
+    this.state = {};
+  }
+
+  render() {
+    return \`
+      <div class="${name.toLowerCase()}" data-component="${className}">
+        <h2>\${this.props.title || '${className}'}</h2>
+        \${this.children}
+      </div>
+    \`;
+  }
+}
+
+module.exports = ${className};
+`;
+    writeFile(filePath, content);
+  },
+
+  model(name, cwd) {
+    const filePath = path.join(cwd, 'models', `${capitalize(name)}.js`);
+    const className = capitalize(name);
+    const tableName = name.toLowerCase() + 's';
+    const content = `const { Model } = require('voltjs');
+
+class ${className} extends Model {
+  static table = '${tableName}';
+
+  static schema = {
+    name: { type: 'string', required: true, maxLength: 255 },
+    email: { type: 'string', required: true },
+    // Add more fields here
+  };
+
+  // Custom methods
+  fullName() {
+    return this.name;
+  }
+}
+
+module.exports = ${className};
+`;
+    writeFile(filePath, content);
+  },
+
+  middleware(name, cwd) {
+    const filePath = path.join(cwd, 'middleware', `${name}.js`);
+    const content = `/**
+ * Middleware: ${name}
+ * 
+ * Usage in app.js:
+ *   const ${name} = require('./middleware/${name}');
+ *   app.use(${name});
+ *   // or on specific routes:
+ *   app.get('/protected', ${name}, handler);
+ */
+
+module.exports = function ${name}(req, res) {
+  // Your middleware logic here
+  // Return false to stop the request
+  // Return nothing (undefined) to continue to next middleware
+  
+  console.log('[${name}]', req.method, req.url);
+};
+`;
+    writeFile(filePath, content);
+  },
+
+  migration(name, cwd) {
+    const timestamp = Date.now();
+    const filePath = path.join(cwd, 'database', 'migrations', `${timestamp}_${name}.js`);
+    const tableName = name.replace(/^create_/, '').replace(/_table$/, '');
+    const content = `/**
+ * Migration: ${name}
+ * Created: ${new Date().toISOString()}
+ */
+
+module.exports = {
+  async up(db) {
+    await db.query(\`
+      CREATE TABLE IF NOT EXISTS ${tableName} (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name VARCHAR(255) NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    \`);
+  },
+
+  async down(db) {
+    await db.query('DROP TABLE IF EXISTS ${tableName}');
+  },
+};
+`;
+    writeFile(filePath, content);
+  },
+
+  seeder(name, cwd) {
+    const filePath = path.join(cwd, 'database', 'seeders', `${name}.js`);
+    const content = `/**
+ * Seeder: ${name}
+ * Run: volt db:seed
+ */
+
+module.exports = {
+  async run(db) {
+    // await db.query("INSERT INTO table_name (col) VALUES (?)", ['value']);
+    console.log('Seeder ${name} executed');
+  },
+};
+`;
+    writeFile(filePath, content);
+  },
+};
+
+module.exports = function generate(args) {
+  const type = args[0];
+  const name = args[1];
+
+  if (!type) {
+    console.log(`${c.bold}Usage:${c.reset} volt generate <type> <name>\n`);
+    console.log(`${c.bold}Types:${c.reset}`);
+    console.log(`  ${c.cyan}page${c.reset}        Generate a page with view`);
+    console.log(`  ${c.cyan}api${c.reset}         Generate an API route`);
+    console.log(`  ${c.cyan}component${c.reset}   Generate a component`);
+    console.log(`  ${c.cyan}model${c.reset}       Generate a database model`);
+    console.log(`  ${c.cyan}middleware${c.reset}   Generate middleware`);
+    console.log(`  ${c.cyan}migration${c.reset}   Generate a database migration`);
+    console.log(`  ${c.cyan}seeder${c.reset}      Generate a database seeder`);
+    process.exit(0);
+  }
+
+  if (!name) {
+    console.error(`${c.red}Error: Please specify a name.${c.reset}`);
+    console.log(`  ${c.cyan}volt generate ${type} <name>${c.reset}`);
+    process.exit(1);
+  }
+
+  const generator = generators[type];
+  if (!generator) {
+    console.error(`${c.red}Error: Unknown generator type "${type}".${c.reset}`);
+    console.log(`Available: ${Object.keys(generators).join(', ')}`);
+    process.exit(1);
+  }
+
+  generator(name, process.cwd());
+};
+
+function writeFile(filePath, content) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+  if (fs.existsSync(filePath)) {
+    console.log(`  ${c.yellow}⚠ Already exists:${c.reset} ${path.relative(process.cwd(), filePath)}`);
+    return;
+  }
+
+  fs.writeFileSync(filePath, content);
+  console.log(`  ${c.green}✓ Created:${c.reset} ${path.relative(process.cwd(), filePath)}`);
+}
+
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+function singularize(str) {
+  if (str.endsWith('ies')) return str.slice(0, -3) + 'y';
+  if (str.endsWith('ses') || str.endsWith('xes')) return str.slice(0, -2);
+  if (str.endsWith('s') && !str.endsWith('ss')) return str.slice(0, -1);
+  return str;
+}

package/src/cli/lint.js

@@ -0,0 +1,172 @@
+/**
+ * VoltJS CLI — `volt lint`
+ * Basic linting for VoltJS projects.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const c = {
+  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+  red: '\x1b[31m', green: '\x1b[32m', yellow: '\x1b[33m', cyan: '\x1b[36m',
+};
+
+module.exports = function lint(args) {
+  const cwd = process.cwd();
+  console.log(`${c.cyan}${c.bold}⚡ VoltJS Lint${c.reset}\n`);
+
+  const issues = [];
+  const scannedFiles = [];
+  const dirs = ['pages', 'api', 'models', 'middleware', 'components'];
+
+  // Scan root JS files
+  for (const file of ['app.js', 'index.js', 'server.js']) {
+    const filePath = path.join(cwd, file);
+    if (fs.existsSync(filePath)) {
+      lintFile(filePath, issues, scannedFiles);
+    }
+  }
+
+  // Scan directories
+  for (const dir of dirs) {
+    const dirPath = path.join(cwd, dir);
+    if (fs.existsSync(dirPath)) {
+      scanAndLint(dirPath, issues, scannedFiles);
+    }
+  }
+
+  // Check config
+  checkConfig(cwd, issues);
+
+  // Report
+  if (issues.length === 0) {
+    console.log(`  ${c.green}✓ No issues found!${c.reset} (${scannedFiles.length} files scanned)`);
+  } else {
+    const warnings = issues.filter(i => i.severity === 'warning');
+    const errors = issues.filter(i => i.severity === 'error');
+
+    for (const issue of issues) {
+      const icon = issue.severity === 'error' ? `${c.red}✗` : `${c.yellow}⚠`;
+      const relative = path.relative(cwd, issue.file);
+      console.log(`  ${icon} ${relative}${issue.line ? `:${issue.line}` : ''}${c.reset} — ${issue.message}`);
+    }
+
+    console.log(`\n  ${c.dim}${scannedFiles.length} files scanned${c.reset}`);
+    if (errors.length > 0) console.log(`  ${c.red}${errors.length} error(s)${c.reset}`);
+    if (warnings.length > 0) console.log(`  ${c.yellow}${warnings.length} warning(s)${c.reset}`);
+  }
+};
+
+function scanAndLint(dir, issues, scannedFiles) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      scanAndLint(fullPath, issues, scannedFiles);
+    } else if (entry.name.endsWith('.js')) {
+      lintFile(fullPath, issues, scannedFiles);
+    }
+  }
+}
+
+function lintFile(filePath, issues, scannedFiles) {
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const lines = content.split('\n');
+  scannedFiles.push(filePath);
+
+  // Check for syntax errors
+  try {
+    new Function(content);
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      issues.push({
+        file: filePath,
+        line: null,
+        severity: 'error',
+        message: `Syntax error: ${err.message}`,
+      });
+    }
+  }
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNum = i + 1;
+
+    // console.log in production code
+    if (line.match(/console\.(log|dir|table)\s*\(/) && !filePath.includes('test')) {
+      issues.push({
+        file: filePath,
+        line: lineNum,
+        severity: 'warning',
+        message: 'Consider removing console.log in production code',
+      });
+    }
+
+    // eval usage
+    if (line.match(/\beval\s*\(/)) {
+      issues.push({
+        file: filePath,
+        line: lineNum,
+        severity: 'error',
+        message: 'Avoid using eval() — security risk',
+      });
+    }
+
+    // Hardcoded secrets
+    if (line.match(/(password|secret|api_key|apikey|token)\s*[:=]\s*['"][^'"]{8,}['"]/i)) {
+      if (!line.includes('process.env') && !filePath.includes('.env')) {
+        issues.push({
+          file: filePath,
+          line: lineNum,
+          severity: 'error',
+          message: 'Possible hardcoded secret detected — use environment variables',
+        });
+      }
+    }
+
+    // Very long lines
+    if (line.length > 200) {
+      issues.push({
+        file: filePath,
+        line: lineNum,
+        severity: 'warning',
+        message: `Line too long (${line.length} chars)`,
+      });
+    }
+  }
+}
+
+function checkConfig(cwd, issues) {
+  // Missing .env
+  if (!fs.existsSync(path.join(cwd, '.env'))) {
+    issues.push({
+      file: path.join(cwd, '.env'),
+      severity: 'warning',
+      message: 'No .env file found — create one for environment variables',
+    });
+  }
+
+  // .env in .gitignore
+  const gitignore = path.join(cwd, '.gitignore');
+  if (fs.existsSync(gitignore)) {
+    const content = fs.readFileSync(gitignore, 'utf-8');
+    if (!content.includes('.env')) {
+      issues.push({
+        file: gitignore,
+        severity: 'error',
+        message: '.env is not in .gitignore — secrets may be committed',
+      });
+    }
+  }
+
+  // Missing volt.config.js
+  if (!fs.existsSync(path.join(cwd, 'volt.config.js'))) {
+    issues.push({
+      file: path.join(cwd, 'volt.config.js'),
+      severity: 'warning',
+      message: 'No volt.config.js — using defaults',
+    });
+  }
+}

package/src/cli/routes.js

@@ -0,0 +1,118 @@
+/**
+ * VoltJS CLI — `volt routes`
+ * Lists all registered routes in the application.
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+
+const c = {
+  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+  red: '\x1b[31m', green: '\x1b[32m', yellow: '\x1b[33m', cyan: '\x1b[36m',
+  magenta: '\x1b[35m',
+};
+
+const METHOD_COLORS = {
+  GET: c.green,
+  POST: c.cyan,
+  PUT: c.yellow,
+  PATCH: c.yellow,
+  DELETE: c.red,
+};
+
+module.exports = function routes(args) {
+  const cwd = process.cwd();
+
+  console.log(`${c.cyan}${c.bold}⚡ VoltJS Routes${c.reset}\n`);
+
+  const allRoutes = [];
+
+  // Scan pages directory
+  const pagesDir = path.join(cwd, 'pages');
+  if (fs.existsSync(pagesDir)) {
+    scanDir(pagesDir, pagesDir, '', allRoutes, 'page');
+  }
+
+  // Scan api directory
+  const apiDir = path.join(cwd, 'api');
+  if (fs.existsSync(apiDir)) {
+    scanDir(apiDir, apiDir, '/api', allRoutes, 'api');
+  }
+
+  // Try to load app and discover programmatic routes
+  try {
+    // We'll just display file-based routes since loading the app might start the server
+  } catch { }
+
+  if (allRoutes.length === 0) {
+    console.log(`  ${c.dim}No routes found. Create files in pages/ or api/ directories.${c.reset}`);
+    return;
+  }
+
+  // Print table header
+  const methodWidth = 8;
+  const pathWidth = 40;
+  const sourceWidth = 30;
+
+  console.log(
+    `  ${c.bold}${'METHOD'.padEnd(methodWidth)}${'PATH'.padEnd(pathWidth)}${'SOURCE'.padEnd(sourceWidth)}${c.reset}`
+  );
+  console.log(`  ${'─'.repeat(methodWidth + pathWidth + sourceWidth)}`);
+
+  for (const route of allRoutes) {
+    const methodColor = METHOD_COLORS[route.method] || c.dim;
+    console.log(
+      `  ${methodColor}${route.method.padEnd(methodWidth)}${c.reset}${route.path.padEnd(pathWidth)}${c.dim}${route.source.padEnd(sourceWidth)}${c.reset}`
+    );
+  }
+
+  console.log(`\n  ${c.dim}Total: ${allRoutes.length} routes${c.reset}\n`);
+};
+
+function scanDir(baseDir, currentDir, prefix, routes, type) {
+  const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      scanDir(baseDir, path.join(currentDir, entry.name), `${prefix}/${entry.name}`, routes, type);
+    } else if (entry.name.endsWith('.js')) {
+      const routeName = entry.name.replace('.js', '');
+      const routePath = routeName === 'index'
+        ? (prefix || '/')
+        : `${prefix}/${routeName}`;
+
+      const relativePath = path.relative(process.cwd(), path.join(currentDir, entry.name));
+
+      try {
+        const mod = require(path.join(currentDir, entry.name));
+        const methods = ['get', 'post', 'put', 'patch', 'delete'];
+        
+        for (const method of methods) {
+          if (mod[method] || mod[method.toUpperCase()]) {
+            routes.push({
+              method: method.toUpperCase(),
+              path: routePath,
+              source: relativePath,
+            });
+          }
+        }
+
+        // If it exports show/update/destroy, add /:id routes
+        if (mod.show) {
+          routes.push({ method: 'GET', path: `${routePath}/:id`, source: relativePath });
+        }
+        if (mod.update) {
+          routes.push({ method: 'PUT', path: `${routePath}/:id`, source: relativePath });
+        }
+        if (mod.destroy) {
+          routes.push({ method: 'DELETE', path: `${routePath}/:id`, source: relativePath });
+        }
+      } catch {
+        // If we can't load the module, assume GET
+        routes.push({ method: 'GET', path: routePath, source: relativePath });
+      }
+    }
+  }
+}

package/src/cli/start.js

@@ -0,0 +1,42 @@
+/**
+ * VoltJS CLI — `volt start`
+ * Starts the production server.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const c = {
+  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+  red: '\x1b[31m', green: '\x1b[32m', cyan: '\x1b[36m',
+};
+
+module.exports = function start(args) {
+  const cwd = process.cwd();
+  const entry = findEntry(cwd);
+
+  if (!entry) {
+    console.error(`${c.red}Error: No app entry point found (app.js, index.js, or server.js).${c.reset}`);
+    process.exit(1);
+  }
+
+  console.log(`${c.cyan}${c.bold}⚡ VoltJS Production Server${c.reset}`);
+  console.log(`${c.dim}Starting ${path.basename(entry)}...${c.reset}\n`);
+
+  // Set production environment
+  process.env.NODE_ENV = process.env.NODE_ENV || 'production';
+
+  // Load the app
+  require(entry);
+};
+
+function findEntry(cwd) {
+  const candidates = ['app.js', 'index.js', 'server.js', 'src/app.js', 'src/index.js'];
+  for (const file of candidates) {
+    const fullPath = path.join(cwd, file);
+    if (fs.existsSync(fullPath)) return fullPath;
+  }
+  return null;
+}