voltjs-framework 1.0.0

package/src/utils/sms.js

@@ -0,0 +1,243 @@
+/**
+ * VoltJS SMS Module
+ * 
+ * Send SMS messages via various providers (Twilio, Vonage, custom API).
+ * Uses native HTTPS for API calls — zero dependencies.
+ * 
+ * @example
+ * const { SMS } = require('voltjs');
+ * 
+ * const sms = new SMS({
+ *   provider: 'twilio',
+ *   accountSid: 'your_sid',
+ *   authToken: 'your_token',
+ *   from: '+1234567890',
+ * });
+ * 
+ * await sms.send('+0987654321', 'Hello from VoltJS!');
+ */
+
+'use strict';
+
+const https = require('https');
+const http = require('http');
+
+class SMS {
+  constructor(config = {}) {
+    this._config = {
+      provider: config.provider || 'custom',
+      from: config.from || process.env.SMS_FROM || '',
+      // Twilio
+      accountSid: config.accountSid || process.env.TWILIO_ACCOUNT_SID || '',
+      authToken: config.authToken || process.env.TWILIO_AUTH_TOKEN || '',
+      // Vonage/Nexmo
+      apiKey: config.apiKey || process.env.VONAGE_API_KEY || '',
+      apiSecret: config.apiSecret || process.env.VONAGE_API_SECRET || '',
+      // Custom API
+      apiUrl: config.apiUrl || process.env.SMS_API_URL || '',
+      apiHeaders: config.apiHeaders || {},
+      apiBodyTemplate: config.apiBodyTemplate || null,
+      ...config,
+    };
+    this._templates = new Map();
+    this._log = [];
+  }
+
+  /** Send an SMS */
+  async send(to, message, options = {}) {
+    const formattedTo = this._formatPhone(to);
+    const formattedMessage = options.template
+      ? this._renderTemplate(options.template, options.data || {})
+      : message;
+
+    let result;
+    switch (this._config.provider.toLowerCase()) {
+      case 'twilio':
+        result = await this._sendTwilio(formattedTo, formattedMessage);
+        break;
+      case 'vonage':
+      case 'nexmo':
+        result = await this._sendVonage(formattedTo, formattedMessage);
+        break;
+      case 'custom':
+        result = await this._sendCustom(formattedTo, formattedMessage);
+        break;
+      case 'console':
+      case 'log':
+        result = this._sendConsole(formattedTo, formattedMessage);
+        break;
+      default:
+        throw new Error(`Unknown SMS provider: ${this._config.provider}`);
+    }
+
+    this._log.push({
+      to: formattedTo,
+      message: formattedMessage.substring(0, 50),
+      provider: this._config.provider,
+      timestamp: new Date(),
+      ...result,
+    });
+
+    return result;
+  }
+
+  /** Send SMS to multiple recipients */
+  async sendBulk(recipients, message, options = {}) {
+    const results = [];
+    for (const to of recipients) {
+      try {
+        const result = await this.send(to, message, options);
+        results.push({ to, status: 'sent', ...result });
+      } catch (err) {
+        results.push({ to, status: 'failed', error: err.message });
+      }
+    }
+    return results;
+  }
+
+  /** Register an SMS template */
+  template(name, template) {
+    this._templates.set(name, template);
+    return this;
+  }
+
+  /** Send OTP SMS */
+  async sendOTP(to, code, options = {}) {
+    const message = options.message || `Your verification code is: ${code}. Valid for ${options.validFor || '10'} minutes.`;
+    return this.send(to, message);
+  }
+
+  /** Get send log */
+  getLog() {
+    return [...this._log];
+  }
+
+  // ===== PROVIDERS =====
+
+  async _sendTwilio(to, body) {
+    const { accountSid, authToken, from } = this._config;
+
+    const postData = new URLSearchParams({
+      To: to,
+      From: from,
+      Body: body,
+    }).toString();
+
+    const response = await this._httpRequest({
+      hostname: 'api.twilio.com',
+      path: `/2010-04-01/Accounts/${accountSid}/Messages.json`,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Authorization': 'Basic ' + Buffer.from(`${accountSid}:${authToken}`).toString('base64'),
+        'Content-Length': Buffer.byteLength(postData),
+      },
+    }, postData);
+
+    return { success: true, provider: 'twilio', sid: response.sid };
+  }
+
+  async _sendVonage(to, text) {
+    const { apiKey, apiSecret, from } = this._config;
+
+    const postData = JSON.stringify({
+      api_key: apiKey,
+      api_secret: apiSecret,
+      to: to.replace(/\+/g, ''),
+      from,
+      text,
+    });
+
+    const response = await this._httpRequest({
+      hostname: 'rest.nexmo.com',
+      path: '/sms/json',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(postData),
+      },
+    }, postData);
+
+    return { success: true, provider: 'vonage', response };
+  }
+
+  async _sendCustom(to, message) {
+    const { apiUrl, apiHeaders, apiBodyTemplate } = this._config;
+    if (!apiUrl) throw new Error('Custom SMS provider requires apiUrl');
+
+    const urlObj = new URL(apiUrl);
+    let body;
+
+    if (apiBodyTemplate) {
+      body = JSON.stringify(apiBodyTemplate)
+        .replace(/\{\{to\}\}/g, to)
+        .replace(/\{\{message\}\}/g, message)
+        .replace(/\{\{from\}\}/g, this._config.from);
+    } else {
+      body = JSON.stringify({ to, message, from: this._config.from });
+    }
+
+    const response = await this._httpRequest({
+      hostname: urlObj.hostname,
+      port: urlObj.port,
+      path: urlObj.pathname + urlObj.search,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+        ...apiHeaders,
+      },
+    }, body);
+
+    return { success: true, provider: 'custom', response };
+  }
+
+  _sendConsole(to, message) {
+    console.log(`\x1b[36m  📱 SMS [${this._config.from} → ${to}]: ${message}\x1b[0m`);
+    return { success: true, provider: 'console' };
+  }
+
+  // ===== HELPERS =====
+
+  _formatPhone(phone) {
+    let cleaned = String(phone).replace(/[^0-9+]/g, '');
+    if (!cleaned.startsWith('+')) {
+      cleaned = '+' + cleaned;
+    }
+    return cleaned;
+  }
+
+  _renderTemplate(name, data) {
+    const template = this._templates.get(name);
+    if (!template) throw new Error(`SMS template "${name}" not found`);
+    return template.replace(/\{\{\s*(.+?)\s*\}\}/g, (_, key) => {
+      return data[key] !== undefined ? String(data[key]) : '';
+    });
+  }
+
+  _httpRequest(options, postData) {
+    return new Promise((resolve, reject) => {
+      const protocol = options.port === 80 ? http : https;
+      const req = protocol.request(options, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(data));
+          } catch {
+            resolve(data);
+          }
+        });
+      });
+      req.on('error', reject);
+      req.setTimeout(10000, () => {
+        req.destroy();
+        reject(new Error('SMS API request timed out'));
+      });
+      if (postData) req.write(postData);
+      req.end();
+    });
+  }
+}
+
+module.exports = { SMS };

package/src/utils/storage.js

@@ -0,0 +1,348 @@
+/**
+ * VoltJS Storage
+ * 
+ * File storage abstraction with local filesystem and S3-compatible support.
+ * 
+ * @example
+ * const { Storage } = require('voltjs');
+ * 
+ * const storage = new Storage({ root: './uploads' });
+ * await storage.put('avatars/user1.png', buffer);
+ * const file = await storage.get('avatars/user1.png');
+ * const url = storage.url('avatars/user1.png');
+ * 
+ * // Upload middleware
+ * app.post('/upload', Storage.upload({ dest: 'uploads', maxSize: 5 * 1024 * 1024 }), handler);
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const https = require('https');
+const http = require('http');
+
+class Storage {
+  constructor(options = {}) {
+    this.driver = options.driver || 'local';
+    this.root = options.root || './storage';
+    this.baseURL = options.baseURL || '/storage';
+
+    // S3 config
+    this.s3 = {
+      bucket: options.bucket || process.env.S3_BUCKET,
+      region: options.region || process.env.S3_REGION || 'us-east-1',
+      accessKey: options.accessKey || process.env.S3_ACCESS_KEY,
+      secretKey: options.secretKey || process.env.S3_SECRET_KEY,
+      endpoint: options.endpoint || process.env.S3_ENDPOINT,
+    };
+
+    if (this.driver === 'local') {
+      if (!fs.existsSync(this.root)) fs.mkdirSync(this.root, { recursive: true });
+    }
+  }
+
+  /** Store a file */
+  async put(filePath, content, options = {}) {
+    if (this.driver === 's3') return this._s3Put(filePath, content, options);
+
+    const fullPath = path.join(this.root, filePath);
+    const dir = path.dirname(fullPath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+    const data = typeof content === 'string' ? Buffer.from(content) : content;
+    fs.writeFileSync(fullPath, data);
+
+    return {
+      path: filePath,
+      size: data.length,
+      url: this.url(filePath),
+    };
+  }
+
+  /** Get file contents */
+  async get(filePath) {
+    if (this.driver === 's3') return this._s3Get(filePath);
+
+    const fullPath = path.join(this.root, filePath);
+    if (!fs.existsSync(fullPath)) return null;
+    return fs.readFileSync(fullPath);
+  }
+
+  /** Get file as string */
+  async getText(filePath) {
+    const buf = await this.get(filePath);
+    return buf ? buf.toString('utf-8') : null;
+  }
+
+  /** Check if file exists */
+  async exists(filePath) {
+    if (this.driver === 's3') return this._s3Exists(filePath);
+    return fs.existsSync(path.join(this.root, filePath));
+  }
+
+  /** Delete a file */
+  async delete(filePath) {
+    if (this.driver === 's3') return this._s3Delete(filePath);
+
+    const fullPath = path.join(this.root, filePath);
+    if (fs.existsSync(fullPath)) {
+      fs.unlinkSync(fullPath);
+      return true;
+    }
+    return false;
+  }
+
+  /** Copy a file */
+  async copy(from, to) {
+    const content = await this.get(from);
+    if (!content) throw new Error(`File not found: ${from}`);
+    return this.put(to, content);
+  }
+
+  /** Move a file */
+  async move(from, to) {
+    await this.copy(from, to);
+    await this.delete(from);
+    return { path: to, url: this.url(to) };
+  }
+
+  /** Get file metadata */
+  async stat(filePath) {
+    if (this.driver === 's3') return this._s3Head(filePath);
+
+    const fullPath = path.join(this.root, filePath);
+    if (!fs.existsSync(fullPath)) return null;
+    const stat = fs.statSync(fullPath);
+    return {
+      size: stat.size,
+      created: stat.birthtime,
+      modified: stat.mtime,
+      isFile: stat.isFile(),
+      isDirectory: stat.isDirectory(),
+    };
+  }
+
+  /** List files in directory */
+  async list(directory = '', options = {}) {
+    if (this.driver === 's3') return this._s3List(directory);
+
+    const fullPath = path.join(this.root, directory);
+    if (!fs.existsSync(fullPath)) return [];
+
+    const items = fs.readdirSync(fullPath, { withFileTypes: true });
+    return items.map(item => ({
+      name: item.name,
+      path: path.join(directory, item.name).replace(/\\/g, '/'),
+      isFile: item.isFile(),
+      isDirectory: item.isDirectory(),
+    }));
+  }
+
+  /** Get public URL for file */
+  url(filePath) {
+    if (this.driver === 's3') {
+      const endpoint = this.s3.endpoint || `https://${this.s3.bucket}.s3.${this.s3.region}.amazonaws.com`;
+      return `${endpoint}/${filePath}`;
+    }
+    return `${this.baseURL}/${filePath}`;
+  }
+
+  /** Create a hash of file contents */
+  async hash(filePath, algorithm = 'md5') {
+    const content = await this.get(filePath);
+    if (!content) return null;
+    return crypto.createHash(algorithm).update(content).digest('hex');
+  }
+
+  /** Generate a unique filename */
+  static uniqueName(originalName) {
+    const ext = path.extname(originalName);
+    const timestamp = Date.now().toString(36);
+    const random = crypto.randomBytes(6).toString('hex');
+    return `${timestamp}-${random}${ext}`;
+  }
+
+  /** Upload middleware for Volt/Express apps */
+  static upload(options = {}) {
+    const dest = options.dest || 'uploads';
+    const maxSize = options.maxSize || 10 * 1024 * 1024; // 10MB
+    const allowedTypes = options.allowedTypes || null; // ['image/png', 'image/jpeg']
+    const storage = new Storage({ root: dest });
+
+    return async (req, res) => {
+      if (!req.files && !req.body?._files) return;
+
+      const files = req.files || req.body?._files || [];
+      const uploaded = [];
+
+      for (const file of (Array.isArray(files) ? files : [files])) {
+        // Size check
+        if (file.data && file.data.length > maxSize) {
+          res.json({ error: `File too large. Maximum: ${(maxSize / 1024 / 1024).toFixed(0)}MB` }, 413);
+          return false;
+        }
+
+        // Type check
+        if (allowedTypes && !allowedTypes.includes(file.type)) {
+          res.json({ error: `File type not allowed: ${file.type}` }, 415);
+          return false;
+        }
+
+        const filename = Storage.uniqueName(file.name || 'upload');
+        const result = await storage.put(filename, file.data);
+        uploaded.push({ ...result, originalName: file.name, type: file.type });
+      }
+
+      req.uploadedFiles = uploaded;
+    };
+  }
+
+  /** Serve static files middleware */
+  static serve(root, options = {}) {
+    const MIME_TYPES = {
+      '.html': 'text/html', '.css': 'text/css', '.js': 'application/javascript',
+      '.json': 'application/json', '.png': 'image/png', '.jpg': 'image/jpeg',
+      '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.svg': 'image/svg+xml',
+      '.ico': 'image/x-icon', '.woff': 'font/woff', '.woff2': 'font/woff2',
+      '.ttf': 'font/ttf', '.pdf': 'application/pdf', '.mp4': 'video/mp4',
+      '.webp': 'image/webp', '.webm': 'video/webm', '.mp3': 'audio/mpeg',
+      '.wav': 'audio/wav', '.txt': 'text/plain', '.xml': 'application/xml',
+    };
+
+    const prefix = options.prefix || '';
+
+    return (req, res) => {
+      if (req.method !== 'GET') return;
+
+      let urlPath = req.url.split('?')[0];
+      if (prefix && !urlPath.startsWith(prefix)) return;
+      if (prefix) urlPath = urlPath.slice(prefix.length);
+
+      const filePath = path.join(root, urlPath);
+      
+      // Security: prevent directory traversal
+      if (!filePath.startsWith(path.resolve(root))) return;
+
+      if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) return;
+
+      const ext = path.extname(filePath);
+      const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+
+      // Cache headers
+      if (options.maxAge) {
+        res.setHeader('Cache-Control', `public, max-age=${options.maxAge}`);
+      }
+
+      res.setHeader('Content-Type', contentType);
+      const stream = fs.createReadStream(filePath);
+      stream.pipe(res);
+      return false; // Stop middleware chain
+    };
+  }
+  
+  // ===== S3 METHODS =====
+
+  async _s3Put(key, content, options = {}) {
+    const data = typeof content === 'string' ? Buffer.from(content) : content;
+    const contentType = options.contentType || 'application/octet-stream';
+    
+    await this._s3Request('PUT', `/${key}`, data, {
+      'Content-Type': contentType,
+      'Content-Length': data.length,
+    });
+
+    return { path: key, size: data.length, url: this.url(key) };
+  }
+
+  async _s3Get(key) {
+    try {
+      return await this._s3Request('GET', `/${key}`);
+    } catch {
+      return null;
+    }
+  }
+
+  async _s3Delete(key) {
+    try {
+      await this._s3Request('DELETE', `/${key}`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async _s3Exists(key) {
+    try {
+      await this._s3Request('HEAD', `/${key}`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async _s3Head(key) {
+    try {
+      const res = await this._s3Request('HEAD', `/${key}`);
+      return { size: parseInt(res.headers?.['content-length'] || 0) };
+    } catch {
+      return null;
+    }
+  }
+
+  async _s3List(prefix = '') {
+    const params = prefix ? `?prefix=${encodeURIComponent(prefix)}` : '';
+    const body = await this._s3Request('GET', `/${params}`);
+    return body; // Raw XML — consumer should parse
+  }
+
+  _s3Request(method, path, body, extraHeaders = {}) {
+    return new Promise((resolve, reject) => {
+      const date = new Date().toUTCString();
+      const host = this.s3.endpoint 
+        ? new URL(this.s3.endpoint).host 
+        : `${this.s3.bucket}.s3.${this.s3.region}.amazonaws.com`;
+
+      const headers = {
+        Host: host,
+        Date: date,
+        ...extraHeaders,
+      };
+
+      // Simple AWS v2 signature
+      if (this.s3.accessKey && this.s3.secretKey) {
+        const stringToSign = `${method}\n\n${headers['Content-Type'] || ''}\n${date}\n/${this.s3.bucket}${path}`;
+        const signature = crypto.createHmac('sha1', this.s3.secretKey).update(stringToSign).digest('base64');
+        headers.Authorization = `AWS ${this.s3.accessKey}:${signature}`;
+      }
+
+      const options = {
+        hostname: host,
+        port: 443,
+        path,
+        method,
+        headers,
+      };
+
+      const req = https.request(options, (res) => {
+        const chunks = [];
+        res.on('data', c => chunks.push(c));
+        res.on('end', () => {
+          const buf = Buffer.concat(chunks);
+          if (res.statusCode >= 400) {
+            reject(new Error(`S3 ${method} ${path} failed: ${res.statusCode}`));
+          } else {
+            resolve(method === 'HEAD' ? { headers: res.headers } : buf);
+          }
+        });
+      });
+
+      req.on('error', reject);
+      if (body) req.write(body);
+      req.end();
+    });
+  }
+}
+
+module.exports = { Storage };