npm - voltjs-framework - Versions diffs - 1.0.0 - Mend

voltjs-framework 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (60) hide show

package/LICENSE +21 -0
package/README.md +1265 -0
package/bin/volt.js +139 -0
package/package.json +56 -0
package/src/api/graphql.js +399 -0
package/src/api/rest.js +204 -0
package/src/api/websocket.js +285 -0
package/src/cli/build.js +111 -0
package/src/cli/create.js +371 -0
package/src/cli/db.js +106 -0
package/src/cli/dev.js +114 -0
package/src/cli/generate.js +278 -0
package/src/cli/lint.js +172 -0
package/src/cli/routes.js +118 -0
package/src/cli/start.js +42 -0
package/src/cli/test.js +138 -0
package/src/core/app.js +701 -0
package/src/core/config.js +232 -0
package/src/core/middleware.js +133 -0
package/src/core/plugins.js +88 -0
package/src/core/react-renderer.js +244 -0
package/src/core/renderer.js +337 -0
package/src/core/router.js +183 -0
package/src/database/index.js +461 -0
package/src/database/migration.js +192 -0
package/src/database/model.js +285 -0
package/src/database/query.js +394 -0
package/src/database/seeder.js +89 -0
package/src/index.js +156 -0
package/src/security/auth.js +425 -0
package/src/security/cors.js +80 -0
package/src/security/csrf.js +125 -0
package/src/security/encryption.js +110 -0
package/src/security/helmet.js +103 -0
package/src/security/index.js +75 -0
package/src/security/rateLimit.js +119 -0
package/src/security/sanitizer.js +113 -0
package/src/security/xss.js +110 -0
package/src/ui/component.js +224 -0
package/src/ui/reactive.js +503 -0
package/src/ui/template.js +448 -0
package/src/utils/cache.js +216 -0
package/src/utils/collection.js +772 -0
package/src/utils/cron.js +213 -0
package/src/utils/date.js +223 -0
package/src/utils/events.js +181 -0
package/src/utils/excel.js +482 -0
package/src/utils/form.js +547 -0
package/src/utils/hash.js +121 -0
package/src/utils/http.js +461 -0
package/src/utils/logger.js +186 -0
package/src/utils/mail.js +347 -0
package/src/utils/paginator.js +179 -0
package/src/utils/pdf.js +417 -0
package/src/utils/queue.js +199 -0
package/src/utils/schema.js +985 -0
package/src/utils/sms.js +243 -0
package/src/utils/storage.js +348 -0
package/src/utils/string.js +236 -0
package/src/utils/validation.js +318 -0

package/src/core/renderer.js ADDED Viewed

@@ -0,0 +1,337 @@
+/**
+ * VoltJS Template Renderer
+ *
+ * Built-in template engine with:
+ * - Mustache-like syntax {{ variable }}
+ * - Conditionals {#if} {#else} {/if}
+ * - Loops {#each items as item} {/each}
+ * - Partials {> partial}
+ * - Layouts {#layout "base"} {/layout}
+ * - Auto-escaping (XSS safe by default)
+ * - Raw output {{{ raw }}}
+ * - Slots {#slot "name"} {/slot}
+ */
+'use strict';
+const fs = require('fs');
+const path = require('path');
+class Renderer {
+  constructor(config) {
+    this._viewsDir = config ? config.get('views.dir', 'views') : 'views';
+    this._cache = new Map();
+    this._cacheEnabled = config ? config.get('views.cache', false) : false;
+    this._helpers = new Map();
+    this._layouts = new Map();
+    this._partials = new Map();
+    // Register default helpers
+    this._registerDefaultHelpers();
+  }
+  setViewsDir(dir) {
+    this._viewsDir = dir;
+  }
+  /** Register a template helper */
+  helper(name, fn) {
+    this._helpers.set(name, fn);
+    return this;
+  }
+  /** Register a layout */
+  layout(name, template) {
+    this._layouts.set(name, template);
+    return this;
+  }
+  /** Register a partial */
+  partial(name, template) {
+    this._partials.set(name, template);
+    return this;
+  }
+  /** Render a template string or file */
+  render(templateOrPath, data = {}) {
+    let template;
+    // Check if it's a file path
+    if (!templateOrPath.includes('{{') && !templateOrPath.includes('{#')) {
+      template = this._loadTemplate(templateOrPath);
+    } else {
+      template = templateOrPath;
+    }
+    // Add helpers to data
+    const context = {
+      ...data,
+      _helpers: Object.fromEntries(this._helpers),
+    };
+    // Process the template
+    let result = this._process(template, context);
+    return result;
+  }
+  /** Load template from file */
+  _loadTemplate(name) {
+    if (this._cacheEnabled && this._cache.has(name)) {
+      return this._cache.get(name);
+    }
+    const extensions = ['.volt', '.html', '.htm', '.vt'];
+    const viewsDir = path.resolve(this._viewsDir);
+    for (const ext of extensions) {
+      const filePath = path.join(viewsDir, name + ext);
+      try {
+        if (fs.existsSync(filePath)) {
+          const content = fs.readFileSync(filePath, 'utf-8');
+          if (this._cacheEnabled) {
+            this._cache.set(name, content);
+          }
+          return content;
+        }
+      } catch {}
+    }
+    // Try without extension
+    const directPath = path.join(viewsDir, name);
+    try {
+      if (fs.existsSync(directPath)) {
+        return fs.readFileSync(directPath, 'utf-8');
+      }
+    } catch {}
+    // If no file found, treat the input as a template string
+    return `<!DOCTYPE html>
+<html><head><title>VoltJS</title>
+<style>
+  body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; margin: 0; padding: 40px; background: #0a0a0a; color: #e0e0e0; }
+  .container { max-width: 800px; margin: 0 auto; }
+  h1 { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); -webkit-background-clip: text; -webkit-text-fill-color: transparent; }
+</style></head>
+<body><div class="container"><h1>${name}</h1></div></body></html>`;
+  }
+  /** Process template with data */
+  _process(template, data) {
+    let result = template;
+    // Process layouts: {#layout "name"} content {/layout}
+    result = this._processLayouts(result, data);
+    // Process partials: {> partialName}
+    result = this._processPartials(result, data);
+    // Process each loops: {#each items as item} ... {/each}
+    result = this._processEach(result, data);
+    // Process conditionals: {#if condition} ... {#else} ... {/if}
+    result = this._processIf(result, data);
+    // Process raw output: {{{ variable }}}
+    result = result.replace(/\{\{\{\s*(.+?)\s*\}\}\}/g, (_, key) => {
+      return this._resolve(key.trim(), data) || '';
+    });
+    // Process escaped output: {{ variable }}
+    result = result.replace(/\{\{\s*(.+?)\s*\}\}/g, (_, key) => {
+      const value = this._resolve(key.trim(), data);
+      return value !== undefined && value !== null ? this._escape(String(value)) : '';
+    });
+    return result;
+  }
+  /** Process layout directives */
+  _processLayouts(template, data) {
+    const layoutRegex = /\{#layout\s+"([^"]+)"\s*\}([\s\S]*?)\{\/layout\}/g;
+    return template.replace(layoutRegex, (_, layoutName, content) => {
+      let layout = this._layouts.get(layoutName) || this._loadTemplate(`layouts/${layoutName}`);
+      // Replace {#slot "content"} in layout with the content
+      layout = layout.replace(/\{#slot\s+"content"\s*\}[\s\S]*?\{\/slot\}/g, content);
+      // Process named slots
+      const slotRegex = /\{#slot\s+"(\w+)"\s*\}([\s\S]*?)\{\/slot\}/g;
+      layout = layout.replace(slotRegex, (_, slotName, defaultContent) => {
+        const slotContentRegex = new RegExp(`\\{#fill\\s+"${slotName}"\\s*\\}([\\s\\S]*?)\\{\\/fill\\}`, 'g');
+        const slotMatch = slotContentRegex.exec(content);
+        return slotMatch ? slotMatch[1] : defaultContent;
+      });
+      return this._process(layout, data);
+    });
+  }
+  /** Process partial includes */
+  _processPartials(template, data) {
+    return template.replace(/\{>\s*(\S+)\s*\}/g, (_, partialName) => {
+      const partial = this._partials.get(partialName) || this._loadTemplate(`partials/${partialName}`);
+      return this._process(partial, data);
+    });
+  }
+  /** Process each loops */
+  _processEach(template, data) {
+    const eachRegex = /\{#each\s+(\S+)\s+as\s+(\S+)\s*\}([\s\S]*?)\{\/each\}/g;
+    return template.replace(eachRegex, (_, arrayKey, itemName, content) => {
+      const array = this._resolve(arrayKey, data);
+      if (!Array.isArray(array)) return '';
+      return array.map((item, index) => {
+        const itemData = {
+          ...data,
+          [itemName]: item,
+          [`${itemName}_index`]: index,
+          [`${itemName}_first`]: index === 0,
+          [`${itemName}_last`]: index === array.length - 1,
+        };
+        return this._process(content, itemData);
+      }).join('');
+    });
+  }
+  /** Process conditionals */
+  _processIf(template, data) {
+    // Handle nested if/else/elseif
+    const ifRegex = /\{#if\s+(.+?)\s*\}([\s\S]*?)\{\/if\}/g;
+    return template.replace(ifRegex, (_, condition, content) => {
+      // Split by else
+      const parts = content.split(/\{#else\s*\}/);
+      const ifContent = parts[0];
+      const elseContent = parts[1] || '';
+      // Evaluate condition
+      const result = this._evaluateCondition(condition, data);
+      const chosen = result ? ifContent : elseContent;
+      return this._process(chosen, data);
+    });
+  }
+  /** Evaluate a condition */
+  _evaluateCondition(condition, data) {
+    // Handle negation
+    if (condition.startsWith('!')) {
+      return !this._evaluateCondition(condition.slice(1).trim(), data);
+    }
+    // Handle comparison operators
+    const operators = ['===', '!==', '>=', '<=', '>', '<', '==', '!='];
+    for (const op of operators) {
+      if (condition.includes(op)) {
+        const [left, right] = condition.split(op).map(s => s.trim());
+        const leftVal = this._resolve(left, data) ?? left;
+        const rightVal = this._resolve(right, data) ?? right;
+        // Remove quotes from string literals
+        const cleanLeft = typeof leftVal === 'string' ? leftVal.replace(/^['"]|['"]$/g, '') : leftVal;
+        const cleanRight = typeof rightVal === 'string' ? rightVal.replace(/^['"]|['"]$/g, '') : rightVal;
+        switch (op) {
+          case '===': case '==': return cleanLeft == cleanRight;
+          case '!==': case '!=': return cleanLeft != cleanRight;
+          case '>': return cleanLeft > cleanRight;
+          case '<': return cleanLeft < cleanRight;
+          case '>=': return cleanLeft >= cleanRight;
+          case '<=': return cleanLeft <= cleanRight;
+        }
+      }
+    }
+    // Handle && and ||
+    if (condition.includes('&&')) {
+      return condition.split('&&').every(c => this._evaluateCondition(c.trim(), data));
+    }
+    if (condition.includes('||')) {
+      return condition.split('||').some(c => this._evaluateCondition(c.trim(), data));
+    }
+    // Simple truthiness check
+    const value = this._resolve(condition, data);
+    return !!value;
+  }
+  /** Resolve a dot-notation key from data */
+  _resolve(key, data) {
+    // Handle string literals
+    if ((key.startsWith('"') && key.endsWith('"')) || (key.startsWith("'") && key.endsWith("'"))) {
+      return key.slice(1, -1);
+    }
+    // Handle numbers
+    if (!isNaN(key)) return Number(key);
+    // Handle booleans
+    if (key === 'true') return true;
+    if (key === 'false') return false;
+    if (key === 'null') return null;
+    // Handle helper calls: helperName(arg1, arg2)
+    const helperMatch = key.match(/^(\w+)\((.+)\)$/);
+    if (helperMatch) {
+      const helperName = helperMatch[1];
+      const helper = this._helpers.get(helperName);
+      if (helper) {
+        const args = helperMatch[2].split(',').map(a => {
+          const trimmed = a.trim();
+          return this._resolve(trimmed, data);
+        });
+        return helper(...args);
+      }
+    }
+    // Dot-notation resolution
+    const parts = key.split('.');
+    let value = data;
+    for (const part of parts) {
+      if (value === undefined || value === null) return undefined;
+      value = value[part];
+    }
+    return value;
+  }
+  /** HTML escape (XSS protection) */
+  _escape(str) {
+    const escapeMap = {
+      '&': '&amp;',
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      "'": '&#x27;',
+      '`': '&#x60;',
+    };
+    return str.replace(/[&<>"'`]/g, c => escapeMap[c]);
+  }
+  /** Register default helpers */
+  _registerDefaultHelpers() {
+    this.helper('uppercase', (str) => String(str).toUpperCase());
+    this.helper('lowercase', (str) => String(str).toLowerCase());
+    this.helper('capitalize', (str) => String(str).charAt(0).toUpperCase() + String(str).slice(1));
+    this.helper('truncate', (str, len) => {
+      const s = String(str);
+      return s.length > len ? s.substring(0, len) + '...' : s;
+    });
+    this.helper('date', (d) => new Date(d).toLocaleDateString());
+    this.helper('json', (v) => JSON.stringify(v, null, 2));
+    this.helper('length', (arr) => Array.isArray(arr) ? arr.length : String(arr).length);
+    this.helper('currency', (num, symbol = '$') => `${symbol}${Number(num).toFixed(2)}`);
+    this.helper('pluralize', (count, singular, plural) => count === 1 ? singular : (plural || singular + 's'));
+    this.helper('default', (val, defaultVal) => val || defaultVal);
+  }
+  /** Clear template cache */
+  clearCache() {
+    this._cache.clear();
+  }
+}
+module.exports = { Renderer };

package/src/core/router.js ADDED Viewed

@@ -0,0 +1,183 @@
+/**
+ * VoltJS Router
+ *
+ * High-performance router with support for:
+ * - Dynamic parameters (:id)
+ * - Wildcards (*)
+ * - Route groups with prefixes
+ * - Named routes
+ * - Route middleware
+ * - Optional parameters (:id?)
+ * - Regex constraints
+ */
+'use strict';
+class Router {
+  constructor(prefix = '') {
+    this._routes = [];
+    this._prefix = prefix;
+    this._namedRoutes = new Map();
+    this._routeMiddleware = new Map();
+  }
+  /**
+   * Add a route
+   */
+  add(method, routePath, handlers) {
+    const fullPath = this._normalizePath(this._prefix + routePath);
+    const route = {
+      method: method.toUpperCase(),
+      path: fullPath,
+      handlers: Array.isArray(handlers) ? handlers : [handlers],
+      pattern: this._buildPattern(fullPath),
+      paramNames: this._extractParamNames(fullPath),
+      name: null,
+    };
+    this._routes.push(route);
+    // Return chainable object for naming routes
+    return {
+      name: (routeName) => {
+        route.name = routeName;
+        this._namedRoutes.set(routeName, route);
+        return this;
+      },
+      middleware: (...mw) => {
+        route.handlers = [...mw, ...route.handlers];
+        return this;
+      },
+    };
+  }
+  /**
+   * Match a request to a route
+   */
+  match(method, requestPath) {
+    const normalizedPath = this._normalizePath(requestPath);
+    for (const route of this._routes) {
+      if (route.method !== method.toUpperCase() && route.method !== 'ALL') {
+        continue;
+      }
+      const match = normalizedPath.match(route.pattern);
+      if (match) {
+        const params = {};
+        route.paramNames.forEach((name, i) => {
+          params[name] = decodeURIComponent(match[i + 1]);
+        });
+        return {
+          route,
+          params,
+          handlers: route.handlers.filter(h => typeof h === 'function'),
+          path: route.path,
+        };
+      }
+    }
+    return null;
+  }
+  /**
+   * Create a route group with shared prefix
+   */
+  group(prefix) {
+    const groupRouter = new Router(this._prefix + prefix);
+    groupRouter._routes = this._routes; // Share routes array
+    groupRouter._namedRoutes = this._namedRoutes;
+    return {
+      get: (path, ...handlers) => groupRouter.add('GET', path, handlers),
+      post: (path, ...handlers) => groupRouter.add('POST', path, handlers),
+      put: (path, ...handlers) => groupRouter.add('PUT', path, handlers),
+      patch: (path, ...handlers) => groupRouter.add('PATCH', path, handlers),
+      delete: (path, ...handlers) => groupRouter.add('DELETE', path, handlers),
+      all: (path, ...handlers) => groupRouter.add('ALL', path, handlers),
+      group: (subPrefix) => groupRouter.group(subPrefix),
+      resource: (name, controller) => {
+        const base = `/${name}`;
+        groupRouter.add('GET', base, [controller.index || controller.list]);
+        groupRouter.add('GET', `${base}/:id`, [controller.show || controller.get]);
+        groupRouter.add('POST', base, [controller.create || controller.store]);
+        groupRouter.add('PUT', `${base}/:id`, [controller.update]);
+        groupRouter.add('PATCH', `${base}/:id`, [controller.update]);
+        groupRouter.add('DELETE', `${base}/:id`, [controller.destroy || controller.remove || controller.delete]);
+      },
+    };
+  }
+  /**
+   * Get URL for named route
+   */
+  url(name, params = {}) {
+    const route = this._namedRoutes.get(name);
+    if (!route) throw new Error(`Route "${name}" not found`);
+    let url = route.path;
+    for (const [key, value] of Object.entries(params)) {
+      url = url.replace(`:${key}`, encodeURIComponent(value));
+    }
+    return url;
+  }
+  /**
+   * Get all registered routes
+   */
+  getRoutes() {
+    return this._routes.map(r => ({
+      method: r.method,
+      path: r.path,
+      name: r.name,
+      handlers: r.handlers.length,
+    }));
+  }
+  // ===== INTERNAL =====
+  _normalizePath(p) {
+    return '/' + p.split('/').filter(Boolean).join('/');
+  }
+  _buildPattern(routePath) {
+    const parts = routePath.split('/').filter(Boolean);
+    const patternParts = parts.map(part => {
+      // Wildcard
+      if (part === '*') return '(.+)';
+      // Optional parameter :name?
+      if (part.startsWith(':') && part.endsWith('?')) {
+        const paramName = part.slice(1, -1);
+        return '([^/]*)?';
+      }
+      // Dynamic parameter :name
+      if (part.startsWith(':')) {
+        return '([^/]+)';
+      }
+      // Literal
+      return part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    });
+    const pattern = '^/' + patternParts.join('/') + '/?$';
+    return new RegExp(pattern, 'i');
+  }
+  _extractParamNames(routePath) {
+    const names = [];
+    const parts = routePath.split('/').filter(Boolean);
+    for (const part of parts) {
+      if (part === '*') {
+        names.push('wildcard');
+      } else if (part.startsWith(':')) {
+        names.push(part.slice(1).replace('?', ''));
+      }
+    }
+    return names;
+  }
+}
+module.exports = { Router };