voltjs-framework 1.0.0

package/bin/volt.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+
+/**
+ * VoltJS CLI - The command center for VoltJS framework
+ * Usage:
+ *   volt create <project-name>   Create a new VoltJS project
+ *   volt dev                     Start development server with hot reload
+ *   volt build                   Build for production
+ *   volt generate <type> <name>  Generate components, pages, APIs
+ *   volt db:migrate              Run database migrations
+ *   volt db:seed                 Seed the database
+ *   volt lint                    Lint your project
+ *   volt test                    Run tests
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+
+// CLI colors without dependencies
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  bgBlue: '\x1b[44m',
+  bgMagenta: '\x1b[45m',
+};
+
+function logo() {
+  console.log(`
+${c.cyan}${c.bold}
+  ██╗   ██╗ ██████╗ ██╗  ████████╗     ██╗███████╗
+  ██║   ██║██╔═══██╗██║  ╚══██╔══╝     ██║██╔════╝
+  ██║   ██║██║   ██║██║     ██║        ██║███████╗
+  ╚██╗ ██╔╝██║   ██║██║     ██║   ██   ██║╚════██║
+   ╚████╔╝ ╚██████╔╝███████╗██║   ╚█████╔╝███████║
+    ╚═══╝   ╚═════╝ ╚══════╝╚═╝    ╚════╝ ╚══════╝
+${c.reset}
+  ${c.dim}Lightning-fast, batteries-included framework${c.reset}
+  ${c.dim}Version 1.0.0${c.reset}
+`);
+}
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+if (!command || command === '--help' || command === '-h') {
+  logo();
+  console.log(`${c.bold}Usage:${c.reset}
+  ${c.cyan}volt create${c.reset} <project-name>        Create a new VoltJS project
+  ${c.cyan}volt dev${c.reset}                           Start dev server (port 3000)
+  ${c.cyan}volt build${c.reset}                         Build for production
+  ${c.cyan}volt start${c.reset}                         Start production server
+  ${c.cyan}volt generate${c.reset} <type> <name>        Generate code (page, api, component, model)
+  ${c.cyan}volt db:migrate${c.reset}                    Run database migrations
+  ${c.cyan}volt db:seed${c.reset}                       Run database seeders
+  ${c.cyan}volt db:rollback${c.reset}                   Rollback last migration
+  ${c.cyan}volt lint${c.reset}                          Lint project files
+  ${c.cyan}volt test${c.reset}                          Run tests
+  ${c.cyan}volt routes${c.reset}                        List all registered routes
+  ${c.cyan}volt --version${c.reset}                     Show version
+
+${c.bold}Examples:${c.reset}
+  ${c.dim}$ volt create my-app${c.reset}
+  ${c.dim}$ volt generate page dashboard${c.reset}
+  ${c.dim}$ volt generate api users${c.reset}
+  ${c.dim}$ volt generate component Header${c.reset}
+`);
+  process.exit(0);
+}
+
+if (command === '--version' || command === '-v') {
+  const pkg = require(path.join(__dirname, '..', 'package.json'));
+  console.log(`VoltJS v${pkg.version}`);
+  process.exit(0);
+}
+
+// Route to appropriate CLI handler
+try {
+  switch (command) {
+    case 'create':
+      require('../src/cli/create')(args.slice(1));
+      break;
+    case 'dev':
+      require('../src/cli/dev')(args.slice(1));
+      break;
+    case 'build':
+      require('../src/cli/build')(args.slice(1));
+      break;
+    case 'start':
+      require('../src/cli/start')(args.slice(1));
+      break;
+    case 'generate':
+    case 'g':
+      require('../src/cli/generate')(args.slice(1));
+      break;
+    case 'db:migrate':
+      require('../src/cli/db')([ 'migrate', ...args.slice(1) ]);
+      break;
+    case 'db:seed':
+      require('../src/cli/db')([ 'seed', ...args.slice(1) ]);
+      break;
+    case 'db:rollback':
+      require('../src/cli/db')([ 'rollback', ...args.slice(1) ]);
+      break;
+    case 'routes':
+      require('../src/cli/routes')(args.slice(1));
+      break;
+    case 'lint':
+      require('../src/cli/lint')(args.slice(1));
+      break;
+    case 'test':
+      require('../src/cli/test')(args.slice(1));
+      break;
+    default:
+      console.error(`${c.red}Unknown command: ${command}${c.reset}`);
+      console.log(`Run ${c.cyan}volt --help${c.reset} for usage information.`);
+      process.exit(1);
+  }
+} catch (err) {
+  if (err.code === 'MODULE_NOT_FOUND') {
+    console.error(`${c.red}Error: Command module not found. Please reinstall VoltJS.${c.reset}`);
+    console.error(`${c.dim}${err.message}${c.reset}`);
+  } else {
+    console.error(`${c.red}Error: ${err.message}${c.reset}`);
+    if (process.env.VOLT_DEBUG) {
+      console.error(err.stack);
+    }
+  }
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "voltjs-framework",
+  "version": "1.0.0",
+  "description": "VoltJS - Lightning-fast, batteries-included, security-first JavaScript framework. Zero boilerplate, maximum power.",
+  "main": "src/index.js",
+  "bin": {
+    "volt": "./bin/volt.js"
+  },
+  "scripts": {
+    "test": "node tests/run.js",
+    "dev": "node bin/volt.js dev",
+    "build": "node bin/volt.js build",
+    "lint": "node bin/volt.js lint"
+  },
+  "keywords": [
+    "framework",
+    "voltjs",
+    "volt-framework",
+    "fullstack",
+    "ssr",
+    "react-ssr",
+    "security",
+    "batteries-included",
+    "minimal",
+    "reactive",
+    "web-framework",
+    "nodejs",
+    "rest-api",
+    "orm",
+    "authentication"
+  ],
+  "author": "cool_phosphorus",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "src/",
+    "bin/",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "ws": "^8.16.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "homepage": "https://voltjs.dev",
+  "bugs": {
+    "url": ""
+  }
+}

package/src/api/graphql.js

@@ -0,0 +1,399 @@
+/**
+ * VoltJS GraphQL Handler
+ * 
+ * Lightweight GraphQL execution engine — no external dependencies.
+ * Supports queries, mutations, variables, and introspection basics.
+ * 
+ * @example
+ * const { GraphQLHandler } = require('voltjs');
+ * 
+ * const gql = new GraphQLHandler();
+ * 
+ * gql.type('User', {
+ *   id: 'ID!',
+ *   name: 'String!',
+ *   email: 'String',
+ * });
+ * 
+ * gql.query('user', { id: 'ID!' }, async ({ id }) => {
+ *   return await User.find(id);
+ * });
+ * 
+ * gql.query('users', {}, async () => {
+ *   return await User.all();
+ * });
+ * 
+ * gql.mutation('createUser', { name: 'String!', email: 'String!' }, async (args) => {
+ *   return await User.create(args);
+ * });
+ * 
+ * // Mount as middleware
+ * app.post('/graphql', gql.middleware());
+ */
+
+'use strict';
+
+class GraphQLHandler {
+  constructor(options = {}) {
+    this.types = new Map();
+    this.queries = new Map();
+    this.mutations = new Map();
+    this.subscriptions = new Map();
+    this.middleware_list = options.middleware || [];
+    this.maxDepth = options.maxDepth || 10;
+    this.introspection = options.introspection !== false;
+  }
+
+  /** Define a type */
+  type(name, fields) {
+    this.types.set(name, fields);
+    return this;
+  }
+
+  /** Define a query resolver */
+  query(name, args, resolver) {
+    if (typeof args === 'function') {
+      resolver = args;
+      args = {};
+    }
+    this.queries.set(name, { args, resolver });
+    return this;
+  }
+
+  /** Define a mutation resolver */
+  mutation(name, args, resolver) {
+    if (typeof args === 'function') {
+      resolver = args;
+      args = {};
+    }
+    this.mutations.set(name, { args, resolver });
+    return this;
+  }
+
+  /** Define a subscription resolver */
+  subscription(name, args, resolver) {
+    if (typeof args === 'function') {
+      resolver = args;
+      args = {};
+    }
+    this.subscriptions.set(name, { args, resolver });
+    return this;
+  }
+
+  /** Execute a GraphQL request */
+  async execute(request, context = {}) {
+    try {
+      const { query, variables = {}, operationName } = typeof request === 'string'
+        ? { query: request }
+        : request;
+
+      if (!query) {
+        return { errors: [{ message: 'Query is required' }] };
+      }
+
+      const parsed = this._parse(query);
+      
+      if (!parsed || parsed.length === 0) {
+        return { errors: [{ message: 'Failed to parse query' }] };
+      }
+
+      // Find the operation to execute
+      let operation = parsed[0];
+      if (operationName) {
+        operation = parsed.find(op => op.name === operationName) || parsed[0];
+      }
+
+      const resolvers = operation.type === 'mutation' ? this.mutations : this.queries;
+      const data = {};
+      const errors = [];
+
+      for (const field of operation.fields) {
+        const resolver = resolvers.get(field.name);
+        
+        // Introspection: __schema, __type
+        if (field.name === '__schema' && this.introspection) {
+          data.__schema = this._introspectSchema();
+          continue;
+        }
+        if (field.name === '__type' && this.introspection) {
+          const typeName = this._resolveArgs(field.args, variables).name;
+          data.__type = this._introspectType(typeName);
+          continue;
+        }
+
+        if (!resolver) {
+          errors.push({ message: `Unknown field: ${field.name}`, path: [field.name] });
+          continue;
+        }
+
+        try {
+          const args = this._resolveArgs(field.args, variables);
+          const result = await resolver.resolver(args, context);
+          data[field.alias || field.name] = this._filterFields(result, field.fields);
+        } catch (err) {
+          errors.push({
+            message: err.message,
+            path: [field.name],
+            extensions: { code: err.code || 'INTERNAL_ERROR' },
+          });
+        }
+      }
+
+      const response = { data };
+      if (errors.length > 0) response.errors = errors;
+      return response;
+
+    } catch (error) {
+      return {
+        errors: [{ message: error.message || 'Internal Error' }],
+      };
+    }
+  }
+
+  /** Express/Volt middleware */
+  middleware() {
+    return async (req, res) => {
+      // Only handle POST to the GraphQL endpoint
+      if (req.method === 'GET' && req.query?.query) {
+        const result = await this.execute({
+          query: req.query.query,
+          variables: req.query.variables ? JSON.parse(req.query.variables) : {},
+          operationName: req.query.operationName,
+        }, { req, res });
+        res.json(result);
+        return false;
+      }
+
+      if (req.method === 'POST') {
+        const result = await this.execute(req.body, { req, res });
+        const status = result.errors && !result.data ? 400 : 200;
+        res.json(result, status);
+        return false;
+      }
+    };
+  }
+
+  /** Generate schema SDL string */
+  toSDL() {
+    const lines = [];
+
+    for (const [name, fields] of this.types) {
+      lines.push(`type ${name} {`);
+      for (const [field, type] of Object.entries(fields)) {
+        lines.push(`  ${field}: ${type}`);
+      }
+      lines.push('}', '');
+    }
+
+    if (this.queries.size > 0) {
+      lines.push('type Query {');
+      for (const [name, { args }] of this.queries) {
+        const argStr = Object.keys(args).length > 0
+          ? `(${Object.entries(args).map(([k, v]) => `${k}: ${v}`).join(', ')})`
+          : '';
+        lines.push(`  ${name}${argStr}: JSON`);
+      }
+      lines.push('}', '');
+    }
+
+    if (this.mutations.size > 0) {
+      lines.push('type Mutation {');
+      for (const [name, { args }] of this.mutations) {
+        const argStr = Object.keys(args).length > 0
+          ? `(${Object.entries(args).map(([k, v]) => `${k}: ${v}`).join(', ')})`
+          : '';
+        lines.push(`  ${name}${argStr}: JSON`);
+      }
+      lines.push('}', '');
+    }
+
+    return lines.join('\n');
+  }
+
+  // ===== PARSER =====
+
+  _parse(query) {
+    const operations = [];
+    const cleaned = query.replace(/#.*/g, '').trim();
+    
+    // Match operation blocks: query/mutation Name { ... } or just { ... }
+    const opRegex = /(?:(query|mutation|subscription)\s*(\w*)\s*(?:\(([^)]*)\))?\s*)?{([\s\S]*?)}\s*$/gm;
+    
+    // Simple top-level parse
+    let type = 'query';
+    let name = null;
+    let body = cleaned;
+
+    const opMatch = cleaned.match(/^(query|mutation|subscription)\s*(\w*)\s*(?:\(([^)]*)\))?\s*\{/);
+    if (opMatch) {
+      type = opMatch[1];
+      name = opMatch[2] || null;
+      body = cleaned.slice(opMatch[0].length - 1); // Keep opening {
+    }
+
+    // Remove outer braces
+    body = body.trim();
+    if (body.startsWith('{')) body = body.slice(1);
+    if (body.endsWith('}')) body = body.slice(0, -1);
+
+    const fields = this._parseFields(body);
+
+    operations.push({ type, name, fields });
+    return operations;
+  }
+
+  _parseFields(body) {
+    const fields = [];
+    const tokens = body.trim();
+    if (!tokens) return fields;
+
+    let i = 0;
+    while (i < tokens.length) {
+      // Skip whitespace
+      while (i < tokens.length && /\s/.test(tokens[i])) i++;
+      if (i >= tokens.length) break;
+
+      // Read field name (might have alias)
+      let fieldName = '';
+      let alias = null;
+      while (i < tokens.length && /[\w]/.test(tokens[i])) {
+        fieldName += tokens[i]; i++;
+      }
+      while (i < tokens.length && /\s/.test(tokens[i])) i++;
+
+      // Check for alias
+      if (tokens[i] === ':') {
+        alias = fieldName;
+        i++; // skip :
+        while (i < tokens.length && /\s/.test(tokens[i])) i++;
+        fieldName = '';
+        while (i < tokens.length && /[\w]/.test(tokens[i])) {
+          fieldName += tokens[i]; i++;
+        }
+        while (i < tokens.length && /\s/.test(tokens[i])) i++;
+      }
+
+      if (!fieldName) { i++; continue; }
+
+      // Parse args
+      let args = {};
+      if (tokens[i] === '(') {
+        const argEnd = this._findClosing(tokens, i, '(', ')');
+        const argStr = tokens.slice(i + 1, argEnd);
+        args = this._parseArgs(argStr);
+        i = argEnd + 1;
+        while (i < tokens.length && /\s/.test(tokens[i])) i++;
+      }
+
+      // Parse sub-fields
+      let subFields = null;
+      if (tokens[i] === '{') {
+        const blockEnd = this._findClosing(tokens, i, '{', '}');
+        const subBody = tokens.slice(i + 1, blockEnd);
+        subFields = this._parseFields(subBody);
+        i = blockEnd + 1;
+      }
+
+      fields.push({ name: fieldName, alias, args, fields: subFields });
+    }
+
+    return fields;
+  }
+
+  _parseArgs(argStr) {
+    const args = {};
+    const parts = argStr.split(',');
+    for (const part of parts) {
+      const colonIdx = part.indexOf(':');
+      if (colonIdx === -1) continue;
+      const key = part.slice(0, colonIdx).trim();
+      let value = part.slice(colonIdx + 1).trim();
+
+      // Parse value
+      if (value.startsWith('"') && value.endsWith('"')) {
+        value = value.slice(1, -1);
+      } else if (value.startsWith('$')) {
+        value = { $var: value.slice(1) };
+      } else if (value === 'true') {
+        value = true;
+      } else if (value === 'false') {
+        value = false;
+      } else if (value === 'null') {
+        value = null;
+      } else if (!isNaN(value)) {
+        value = Number(value);
+      }
+
+      args[key] = value;
+    }
+    return args;
+  }
+
+  _resolveArgs(args, variables) {
+    const resolved = {};
+    for (const [key, value] of Object.entries(args)) {
+      if (value && typeof value === 'object' && value.$var) {
+        resolved[key] = variables[value.$var];
+      } else {
+        resolved[key] = value;
+      }
+    }
+    return resolved;
+  }
+
+  _filterFields(data, fields) {
+    if (!fields || !data) return data;
+    if (Array.isArray(data)) {
+      return data.map(item => this._filterFields(item, fields));
+    }
+    if (typeof data !== 'object') return data;
+
+    const result = {};
+    for (const field of fields) {
+      const key = field.name;
+      if (key in data) {
+        result[field.alias || key] = field.fields
+          ? this._filterFields(data[key], field.fields)
+          : data[key];
+      }
+    }
+    return result;
+  }
+
+  _findClosing(str, start, open, close) {
+    let depth = 1;
+    let i = start + 1;
+    while (i < str.length && depth > 0) {
+      if (str[i] === open) depth++;
+      else if (str[i] === close) depth--;
+      if (depth > 0) i++;
+    }
+    return i;
+  }
+
+  // ===== INTROSPECTION =====
+
+  _introspectSchema() {
+    return {
+      queryType: { name: 'Query' },
+      mutationType: this.mutations.size > 0 ? { name: 'Mutation' } : null,
+      types: [...this.types.keys()].map(name => this._introspectType(name)),
+    };
+  }
+
+  _introspectType(name) {
+    const fields = this.types.get(name);
+    if (!fields) return null;
+    return {
+      name,
+      kind: 'OBJECT',
+      fields: Object.entries(fields).map(([fieldName, type]) => ({
+        name: fieldName,
+        type: { name: type.replace('!', ''), kind: 'SCALAR', ofType: null },
+        isDeprecated: false,
+      })),
+    };
+  }
+}
+
+module.exports = { GraphQLHandler };