vibe-gx 2.0.0 → 3.0.0

package/utils/native.js

@@ -1,76 +1,23 @@
 /**
- * Native Module Wrapper
- *
- * Attempts to load the C++ native module for performance.
- * Falls back to pure JavaScript implementations if native module is unavailable.
+ * Pure JavaScript implementations for JSON stringify, URL parsing,
+ * query string parsing, and URI decoding.
  */
 
-import { createRequire } from "module";
-import { fileURLToPath } from "url";
-import path from "path";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-let native = null;
-let useNative = false;
-
-// Try to load native module using createRequire for ESM compatibility
-try {
-  const require = createRequire(import.meta.url);
-  const nativePath = path.join(
-    __dirname,
-    "..",
-    "build",
-    "Release",
-    "vibe_native.node",
-  );
-  native = require(nativePath);
-  useNative = true;
-  console.log("[VIBE] Native module loaded (C++ optimizations enabled)");
-} catch (err) {
-  // Native module not available, use JS fallback
-  console.log(
-    "[VIBE] Native module not available, using JavaScript implementation",
-  );
-}
-
 /**
- * Fast JSON stringify
- * Uses native C++ implementation if available
- *
+ * Fast JSON stringify (pure JS)
  * @param {any} value - Value to stringify
  * @returns {string} JSON string
  */
 export function stringify(value) {
-  if (useNative) {
-    try {
-      return native.stringify(value);
-    } catch {
-      // Fallback on error
-      return JSON.stringify(value);
-    }
-  }
   return JSON.stringify(value);
 }
 
 /**
  * Parse URL into pathname and query object
- * Uses native C++ implementation if available
- *
  * @param {string} url - URL to parse
  * @returns {{ pathname: string, query: Object }}
  */
 export function parseUrl(url) {
-  if (useNative) {
-    try {
-      return native.parseUrl(url);
-    } catch {
-      // Fallback
-    }
-  }
-
-  // JavaScript fallback
   const qIdx = url.indexOf("?");
   if (qIdx < 0) {
     return { pathname: url, query: {} };
@@ -83,25 +30,13 @@ export function parseUrl(url) {
 
 /**
  * Parse query string into object
- * Uses native C++ implementation if available
- *
  * @param {string} queryString - Query string (with or without leading ?)
  * @returns {Object} Parsed query parameters
  */
 export function parseQuery(queryString) {
-  if (useNative) {
-    try {
-      return native.parseQuery(queryString);
-    } catch {
-      // Fallback
-    }
-  }
-
-  // JavaScript fallback
   const query = {};
   if (!queryString) return query;
 
-  // Remove leading ?
   let qs = queryString;
   if (qs[0] === "?") {
     qs = qs.slice(1);
@@ -127,28 +62,19 @@ export function parseQuery(queryString) {
 
 /**
  * Decode URI component
- * Uses native C++ implementation if available
- *
  * @param {string} encoded - Encoded string
  * @returns {string} Decoded string
  */
 export function decodeURI(encoded) {
-  if (useNative) {
-    try {
-      return native.decodeURI(encoded);
-    } catch {
-      // Fallback
-    }
-  }
   return decodeURIComponent(encoded);
 }
 
 /**
- * Check if native module is loaded
+ * Check if native module is loaded (always false now)
  * @returns {boolean}
  */
 export function isNativeEnabled() {
-  return useNative;
+  return false;
 }
 
 /**
@@ -156,7 +82,7 @@ export function isNativeEnabled() {
  * @returns {string|null}
  */
 export function getNativeVersion() {
-  return useNative ? native.version : null;
+  return null;
 }
 
 export default {

package/vibe.js

@@ -3,6 +3,7 @@ import { adapt } from "./utils/helpers/adapt.js";
 import { color } from "./utils/helpers/colors.js";
 import { RouteTrie } from "./utils/core/trie.js";
 import { PathToRegex } from "./utils/core/handler.js";
+import { compileSerializer } from "./utils/core/compile-serializer.js";
 
 /**
  * Helper to generate regex for a path
@@ -195,12 +196,8 @@ const vibe = () => {
       pathRegex: null,
       handler: null,
       intercept: null,
-      media: {
-        public: true,
-        dest: null,
-        maxSize: 10 * 1024 * 1024,
-        allowedTypes: null,
-      },
+      serialize: null,
+      media: null, // Only set when explicitly configured
     };
 
     // Handle overriding root route
@@ -212,7 +209,18 @@ const vibe = () => {
         route.intercept = opts.intercept
           ? wrapIntercepts(opts.intercept)
           : null;
-        route.media = { ...route.media, ...opts.media };
+        if (opts.media) {
+          route.media = {
+            public: true,
+            dest: null,
+            maxSize: 10 * 1024 * 1024,
+            allowedTypes: null,
+            ...opts.media,
+          };
+        }
+        if (opts.schema?.response) {
+          route.serialize = compileSerializer(opts.schema.response);
+        }
         route.handler = handler;
       } else {
         route.handler = opts;
@@ -238,7 +246,18 @@ const vibe = () => {
         throw new Error("Options must be an object when using 3-arg form");
       }
       route.intercept = opts.intercept ? wrapIntercepts(opts.intercept) : null;
-      route.media = { ...route.media, ...opts.media };
+      if (opts.media) {
+        route.media = {
+          public: true,
+          dest: null,
+          maxSize: 10 * 1024 * 1024,
+          allowedTypes: null,
+          ...opts.media,
+        };
+      }
+      if (opts.schema?.response) {
+        route.serialize = compileSerializer(opts.schema.response);
+      }
       route.handler = handler;
     } else {
       route.handler = opts;

package/binding.gyp

@@ -1,36 +0,0 @@
-{
-  "targets": [
-    {
-      "target_name": "vibe_native",
-      "cflags!": ["-fno-exceptions"],
-      "cflags_cc!": ["-fno-exceptions"],
-      "cflags_cc": ["-std=c++17", "-O3"],
-      "sources": [
-        "native/vibe_native.cc",
-        "native/json_stringify.cc",
-        "native/url_parser.cc"
-      ],
-      "include_dirs": [
-        "<!@(node -p \"require('node-addon-api').include\")"
-      ],
-      "defines": ["NAPI_DISABLE_CPP_EXCEPTIONS"],
-      "conditions": [
-        ["OS=='mac'", {
-          "xcode_settings": {
-            "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
-            "CLANG_CXX_LANGUAGE_STANDARD": "c++17",
-            "MACOSX_DEPLOYMENT_TARGET": "10.15"
-          }
-        }],
-        ["OS=='win'", {
-          "msvs_settings": {
-            "VCCLCompilerTool": {
-              "ExceptionHandling": 1,
-              "AdditionalOptions": ["/std:c++17"]
-            }
-          }
-        }]
-      ]
-    }
-  ]
-}

package/native/json_stringify.cc

@@ -1,241 +0,0 @@
-#include "json_stringify.h"
-#include <cmath>
-#include <cstring>
-#include <vector>
-
-namespace vibe {
-
-// Pre-allocated escape table for fast lookup
-static const char* ESCAPE_TABLE[256] = {nullptr};
-static bool escapeTableInitialized = false;
-
-static void initEscapeTable() {
-    if (escapeTableInitialized) return;
-    
-    // Control characters
-    ESCAPE_TABLE['"'] = "\\\"";
-    ESCAPE_TABLE['\\'] = "\\\\";
-    ESCAPE_TABLE['\b'] = "\\b";
-    ESCAPE_TABLE['\f'] = "\\f";
-    ESCAPE_TABLE['\n'] = "\\n";
-    ESCAPE_TABLE['\r'] = "\\r";
-    ESCAPE_TABLE['\t'] = "\\t";
-    
-    escapeTableInitialized = true;
-}
-
-// Fast string builder using pre-allocated buffer
-class FastStringBuilder {
-public:
-    FastStringBuilder() : buffer_(4096) {
-        pos_ = 0;
-    }
-    
-    void reserve(size_t size) {
-        if (buffer_.size() < size) {
-            buffer_.resize(size * 2);
-        }
-    }
-    
-    void append(char c) {
-        ensureCapacity(1);
-        buffer_[pos_++] = c;
-    }
-    
-    void append(const char* str, size_t len) {
-        ensureCapacity(len);
-        memcpy(&buffer_[pos_], str, len);
-        pos_ += len;
-    }
-    
-    void append(const char* str) {
-        append(str, strlen(str));
-    }
-    
-    void appendInt(int64_t value) {
-        char buf[32];
-        int len = snprintf(buf, sizeof(buf), "%ld", value);
-        append(buf, len);
-    }
-    
-    void appendDouble(double value) {
-        char buf[32];
-        int len = snprintf(buf, sizeof(buf), "%.15g", value);
-        append(buf, len);
-    }
-    
-    std::string toString() {
-        return std::string(buffer_.data(), pos_);
-    }
-    
-private:
-    void ensureCapacity(size_t needed) {
-        if (pos_ + needed > buffer_.size()) {
-            buffer_.resize((pos_ + needed) * 2);
-        }
-    }
-    
-    std::vector<char> buffer_;
-    size_t pos_;
-};
-
-// Fast string escape using lookup table
-static void escapeStringFast(FastStringBuilder& sb, const std::string& str) {
-    sb.append('"');
-    
-    const char* data = str.data();
-    size_t len = str.size();
-    size_t lastPos = 0;
-    
-    for (size_t i = 0; i < len; i++) {
-        unsigned char c = static_cast<unsigned char>(data[i]);
-        
-        if (c < 0x20 || c == '"' || c == '\\') {
-            // Flush unescaped segment
-            if (i > lastPos) {
-                sb.append(data + lastPos, i - lastPos);
-            }
-            
-            // Handle escape
-            if (ESCAPE_TABLE[c]) {
-                sb.append(ESCAPE_TABLE[c]);
-            } else {
-                // Control character - use \u escape
-                char buf[8];
-                snprintf(buf, sizeof(buf), "\\u%04x", c);
-                sb.append(buf, 6);
-            }
-            
-            lastPos = i + 1;
-        }
-    }
-    
-    // Flush remaining
-    if (lastPos < len) {
-        sb.append(data + lastPos, len - lastPos);
-    }
-    
-    sb.append('"');
-}
-
-static void stringifyValueFast(FastStringBuilder& sb, const Napi::Value& value, int depth);
-
-static void stringifyArrayFast(FastStringBuilder& sb, const Napi::Array& arr, int depth) {
-    if (depth > 10) {
-        sb.append("null", 4);
-        return;
-    }
-    
-    sb.append('[');
-    uint32_t len = arr.Length();
-    
-    for (uint32_t i = 0; i < len; i++) {
-        if (i > 0) sb.append(',');
-        stringifyValueFast(sb, arr.Get(i), depth + 1);
-    }
-    
-    sb.append(']');
-}
-
-static void stringifyObjectFast(FastStringBuilder& sb, const Napi::Object& obj, int depth) {
-    if (depth > 10) {
-        sb.append("null", 4);
-        return;
-    }
-    
-    sb.append('{');
-    Napi::Array keys = obj.GetPropertyNames();
-    uint32_t len = keys.Length();
-    bool first = true;
-    
-    for (uint32_t i = 0; i < len; i++) {
-        Napi::Value key = keys.Get(i);
-        Napi::Value val = obj.Get(key);
-        
-        if (val.IsUndefined()) continue;
-        
-        if (!first) sb.append(',');
-        first = false;
-        
-        escapeStringFast(sb, key.As<Napi::String>().Utf8Value());
-        sb.append(':');
-        stringifyValueFast(sb, val, depth + 1);
-    }
-    
-    sb.append('}');
-}
-
-static void stringifyValueFast(FastStringBuilder& sb, const Napi::Value& value, int depth) {
-    if (value.IsNull() || value.IsUndefined()) {
-        sb.append("null", 4);
-        return;
-    }
-    
-    if (value.IsBoolean()) {
-        if (value.As<Napi::Boolean>().Value()) {
-            sb.append("true", 4);
-        } else {
-            sb.append("false", 5);
-        }
-        return;
-    }
-    
-    if (value.IsNumber()) {
-        double num = value.As<Napi::Number>().DoubleValue();
-        if (std::isnan(num) || std::isinf(num)) {
-            sb.append("null", 4);
-        } else if (num == static_cast<int64_t>(num) && num >= -9007199254740991.0 && num <= 9007199254740991.0) {
-            sb.appendInt(static_cast<int64_t>(num));
-        } else {
-            sb.appendDouble(num);
-        }
-        return;
-    }
-    
-    if (value.IsString()) {
-        escapeStringFast(sb, value.As<Napi::String>().Utf8Value());
-        return;
-    }
-    
-    if (value.IsArray()) {
-        stringifyArrayFast(sb, value.As<Napi::Array>(), depth);
-        return;
-    }
-    
-    if (value.IsObject()) {
-        Napi::Object obj = value.As<Napi::Object>();
-        
-        // Check for toJSON
-        if (obj.Has("toJSON") && obj.Get("toJSON").IsFunction()) {
-            Napi::Function toJSON = obj.Get("toJSON").As<Napi::Function>();
-            Napi::Value result = toJSON.Call(obj, {});
-            stringifyValueFast(sb, result, depth);
-            return;
-        }
-        
-        stringifyObjectFast(sb, obj, depth);
-        return;
-    }
-    
-    sb.append("null", 4);
-}
-
-Napi::String JsonStringifier::Stringify(const Napi::Env& env, const Napi::Value& value) {
-    initEscapeTable();
-    
-    FastStringBuilder sb;
-    stringifyValueFast(sb, value, 0);
-    return Napi::String::New(env, sb.toString());
-}
-
-Napi::Value FastStringify(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    
-    if (info.Length() < 1) {
-        return Napi::String::New(env, "undefined");
-    }
-    
-    return JsonStringifier::Stringify(env, info[0]);
-}
-
-} // namespace vibe

package/native/json_stringify.h

@@ -1,32 +0,0 @@
-#ifndef JSON_STRINGIFY_H
-#define JSON_STRINGIFY_H
-
-#include <napi.h>
-#include <string>
-#include <sstream>
-
-namespace vibe {
-
-/**
- * Fast JSON stringifier for common cases
- * Handles: strings, numbers, booleans, null, simple objects, arrays
- */
-class JsonStringifier {
-public:
-    static Napi::String Stringify(const Napi::Env& env, const Napi::Value& value);
-    
-private:
-    static void StringifyValue(std::ostringstream& ss, const Napi::Value& value, int depth);
-    static void StringifyObject(std::ostringstream& ss, const Napi::Object& obj, int depth);
-    static void StringifyArray(std::ostringstream& ss, const Napi::Array& arr, int depth);
-    static void EscapeString(std::ostringstream& ss, const std::string& str);
-    
-    static constexpr int MAX_DEPTH = 10;
-};
-
-// N-API wrapper function
-Napi::Value FastStringify(const Napi::CallbackInfo& info);
-
-} // namespace vibe
-
-#endif // JSON_STRINGIFY_H

package/native/url_parser.cc

@@ -1,178 +0,0 @@
-#include "url_parser.h"
-#include <cstring>
-
-namespace vibe {
-
-// Pre-computed hex decode table
-static int HEX_TABLE[256] = {-1};
-static bool hexTableInitialized = false;
-
-static void initHexTable() {
-    if (hexTableInitialized) return;
-    
-    for (int i = 0; i < 256; i++) HEX_TABLE[i] = -1;
-    
-    for (int i = '0'; i <= '9'; i++) HEX_TABLE[i] = i - '0';
-    for (int i = 'a'; i <= 'f'; i++) HEX_TABLE[i] = i - 'a' + 10;
-    for (int i = 'A'; i <= 'F'; i++) HEX_TABLE[i] = i - 'A' + 10;
-    
-    hexTableInitialized = true;
-}
-
-std::string UrlParser::DecodeURIComponent(const std::string& encoded) {
-    initHexTable();
-    
-    std::string result;
-    result.reserve(encoded.size());
-    
-    const char* data = encoded.data();
-    size_t len = encoded.size();
-    
-    for (size_t i = 0; i < len; i++) {
-        char c = data[i];
-        
-        if (c == '%' && i + 2 < len) {
-            int hi = HEX_TABLE[static_cast<unsigned char>(data[i + 1])];
-            int lo = HEX_TABLE[static_cast<unsigned char>(data[i + 2])];
-            
-            if (hi >= 0 && lo >= 0) {
-                result += static_cast<char>((hi << 4) | lo);
-                i += 2;
-                continue;
-            }
-        } else if (c == '+') {
-            result += ' ';
-            continue;
-        }
-        
-        result += c;
-    }
-    
-    return result;
-}
-
-UrlParser::ParseResult UrlParser::Parse(const std::string& url) {
-    ParseResult result;
-    
-    const char* data = url.data();
-    size_t len = url.size();
-    
-    // Find query string start using pointer arithmetic (faster)
-    const char* qmark = static_cast<const char*>(memchr(data, '?', len));
-    
-    if (!qmark) {
-        result.pathname = url;
-        return result;
-    }
-    
-    size_t pathLen = qmark - data;
-    result.pathname = std::string(data, pathLen);
-    
-    // Parse query string
-    const char* queryStart = qmark + 1;
-    size_t queryLen = len - pathLen - 1;
-    
-    const char* pos = queryStart;
-    const char* end = queryStart + queryLen;
-    
-    while (pos < end) {
-        // Find & or end
-        const char* amp = static_cast<const char*>(memchr(pos, '&', end - pos));
-        const char* pairEnd = amp ? amp : end;
-        
-        // Find = in pair
-        size_t pairLen = pairEnd - pos;
-        const char* eq = static_cast<const char*>(memchr(pos, '=', pairLen));
-        
-        if (eq && eq > pos) {
-            std::string key = DecodeURIComponent(std::string(pos, eq - pos));
-            std::string value = DecodeURIComponent(std::string(eq + 1, pairEnd - eq - 1));
-            result.query[key] = value;
-        }
-        
-        pos = pairEnd + 1;
-    }
-    
-    return result;
-}
-
-Napi::Value ParseUrl(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    
-    if (info.Length() < 1 || !info[0].IsString()) {
-        Napi::TypeError::New(env, "URL string expected").ThrowAsJavaScriptException();
-        return env.Null();
-    }
-    
-    std::string url = info[0].As<Napi::String>().Utf8Value();
-    UrlParser::ParseResult parsed = UrlParser::Parse(url);
-    
-    Napi::Object result = Napi::Object::New(env);
-    result.Set("pathname", Napi::String::New(env, parsed.pathname));
-    
-    Napi::Object query = Napi::Object::New(env);
-    for (const auto& pair : parsed.query) {
-        query.Set(pair.first, Napi::String::New(env, pair.second));
-    }
-    result.Set("query", query);
-    
-    return result;
-}
-
-Napi::Value ParseQuery(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    
-    if (info.Length() < 1 || !info[0].IsString()) {
-        return Napi::Object::New(env);
-    }
-    
-    initHexTable();
-    
-    std::string queryString = info[0].As<Napi::String>().Utf8Value();
-    const char* data = queryString.data();
-    size_t len = queryString.size();
-    
-    // Skip leading ?
-    if (len > 0 && data[0] == '?') {
-        data++;
-        len--;
-    }
-    
-    Napi::Object result = Napi::Object::New(env);
-    
-    const char* pos = data;
-    const char* end = data + len;
-    
-    while (pos < end) {
-        const char* amp = static_cast<const char*>(memchr(pos, '&', end - pos));
-        const char* pairEnd = amp ? amp : end;
-        size_t pairLen = pairEnd - pos;
-        
-        const char* eq = static_cast<const char*>(memchr(pos, '=', pairLen));
-        
-        if (eq && eq > pos) {
-            std::string key = UrlParser::DecodeURIComponent(std::string(pos, eq - pos));
-            std::string value = UrlParser::DecodeURIComponent(std::string(eq + 1, pairEnd - eq - 1));
-            result.Set(key, Napi::String::New(env, value));
-        }
-        
-        pos = pairEnd + 1;
-    }
-    
-    return result;
-}
-
-Napi::Value DecodeURI(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    
-    if (info.Length() < 1 || !info[0].IsString()) {
-        return Napi::String::New(env, "");
-    }
-    
-    std::string encoded = info[0].As<Napi::String>().Utf8Value();
-    std::string decoded = UrlParser::DecodeURIComponent(encoded);
-    
-    return Napi::String::New(env, decoded);
-}
-
-} // namespace vibe