corecdtl 0.1.6 → 0.1.8

package/native/http/routes/route_builder.cpp

@@ -1,161 +0,0 @@
-//===----------------------------------------------------------------------===//
-// RouteBuilder - Builder Implementation
-//===----------------------------------------------------------------------===//
-
-#include "route.h"
-
-#include <algorithm>
-#include <map>
-#include <string>
-
-using namespace RouteBuilder;
-
-namespace {
-
-    constexpr char kParamMarker = ':'; ///< marker for parameters in the pattern
-    constexpr char kWildcardMarker = '*'; ///< marker for wildcard all path names in the pattern
-    constexpr int kMaxPacked = 8; ///< maximum bytes to pack into a u64 for comparison
-
-    // Pack up to 8 bytes from `str` into a u64. If len < 8, fill high bytes with 0xFF
-    // to maintain inequality for short vs longer sequences.
-    inline static uint64_t  packU64Safe(const char* str, int len) {
-        if (len <= 0) return 0;
-        if (len > 8) len = 8;
-        uint64_t val = 0;
-        for (int i = 0; i < len; ++i) {
-            uint8_t c = static_cast<uint8_t>(str[i]);
-            val |= (uint64_t)c << (8 * i);
-        }
-        for (int i = len; i < 8; ++i) {
-            val |= (uint64_t)0xFF << (8 * i);
-        }
-        return val;
-    }
-
-    // Helper factory functions to make nodes
-    std::shared_ptr<RouteNode> makeParamNode() {
-        auto n = std::make_shared<RouteNode>();
-        n->is_param = true;
-        n->is_wildcard = false;
-        return n;
-    }
-
-    std::shared_ptr<RouteNode> makeStaticNode() {
-        auto n = std::make_shared<RouteNode>();
-        n->is_param = false;
-        n->is_wildcard = false;
-        return n;
-    }
-
-    std::shared_ptr<RouteNode> makeWildcardNode() {
-        auto n = std::make_shared<RouteNode>();
-        n->is_wildcard = true;
-        n->is_param = false;
-        return n;
-    }
-
-    // offset -> index into the url char array
-    static void buildSubRouteTree(std::shared_ptr<RouteNode> node, const std::vector<Endpoint>& eps, int offset) {
-        if (!node) return;
-        if (eps.empty()) return;
-
-        
-        for (auto &ep : eps) {
-            if (ep.url[offset] == '\0') {
-                // conflict resolution: if multiple endpoints end here, pick one or handle collision
-                node->vptr_table_index = ep.vptr_table_index;
-                // not removing; it's OK to leave them (they represent same path)
-            }
-        }
-        
-        std::vector<Endpoint> param_eps;
-        std::vector<Endpoint> static_eps;
-        Endpoint wildcard_ep;
-
-        for (auto &ep : eps) {
-            char c = ep.url[offset];
-            if (c == '\0') continue;
-
-            if (c == kWildcardMarker) wildcard_ep = ep;
-            else if (c == kParamMarker && ep.url[offset + 1] == '/') param_eps.push_back(ep);
-            else static_eps.push_back(ep);
-        }
-
-        // 3) Handle static prefix group (build common prefix up to MAX_VALUE_EXP)
-        if (!static_eps.empty()) {
-            // Build common prefix character-by-character
-            std::string prefix;
-            for (int p = 0; p < kMaxPacked; ++p) {
-                char ch = static_eps[0].url[offset + p];
-                if (ch == '\0' || ch == kParamMarker || ch == kWildcardMarker) break;
-
-                bool all_match = true;
-                for (auto &se : static_eps) {
-                    if (se.url[offset + p] != ch) { all_match = false; break; }
-                }
-                if (!all_match) break;
-                prefix.push_back(ch);
-            }
-
-            if (!prefix.empty()) {
-                auto static_node = makeStaticNode();
-                static_node->value_length = static_cast<size_t>(prefix.size());
-                static_node->value = packU64Safe(prefix.c_str(), static_node->value_length);
-                node->children.push_back(static_node);
-
-                // recursion on static group with advanced offset
-                int next_offset = offset + static_node->value_length;
-                // pass by reference: note static_eps is a copy local vector
-                buildSubRouteTree(static_node, static_eps, next_offset);
-            } else {
-                // No common multi-char prefix: group by first char and create one child per first character
-                // This reduces worst-case behavior: split by single char
-                // collect buckets
-                std::map<char, std::vector<Endpoint>> buckets;
-                for (auto &se : static_eps) buckets[se.url[offset]].push_back(se);
-                for (auto &kv : buckets) {
-                    char first = kv.first;
-                    std::string onechar(1, first);
-                    auto child = makeStaticNode();
-                    child->value_length = 1;
-                    child->value = packU64Safe(onechar.c_str(), 1);
-                    node->children.push_back(child);
-                    buildSubRouteTree(child, kv.second, offset + 1);
-                }
-            }
-        }
-
-        // 4) Handle param group (there should be at most one param child, but if multiple different param names,
-        //    we might need to disambiguate; here we take the first's metadata)
-        if (!param_eps.empty()) {
-            auto param_node = makeParamNode();
-            // Use the first endpoint's param meta
-            if (!param_eps[0].params.empty()) {
-                param_node->param_name = param_eps[0].params[0].name;
-                param_node->param_type = param_eps[0].params[0].type;
-            }
-            node->children.push_back(param_node);
-            // skip the ":/" marker -> offset + 2
-            buildSubRouteTree(param_node, param_eps, offset + 2);
-        }
-
-        // 5) Wildcard route (terminal matcher)
-        //    Only one wildcard is allowed per route level.
-        //    Wildcard consumes the rest of the URL and must NOT recurse further.
-        //    It acts as a final fallback when no static or param routes match.
-        if (wildcard_ep) {
-            auto wildcard_node = makeWildcardNode();
-            wildcard_node->vptr_table_index = wildcard_ep.vptr_table_index;
-            node->children.push_back(wildcard_node);
-        }
-    }
-}
-
-// Public API
-std::shared_ptr<RouteNode> RouteBuilder::buildRouteTree(const std::vector<Endpoint>& eps) noexcept {
-    if (eps.size() == 0) return nullptr;
-
-    auto root = std::make_shared<RouteNode>();
-    buildSubRouteTree(root, eps, 0);
-    return root;
-}

package/native/http/routes/route_matching.cpp

@@ -1,266 +0,0 @@
-//===----------------------------------------------------------------------===//
-// RouteBuilder - Matcher Implementation
-//===----------------------------------------------------------------------===//
-
-#include "route.h"
-
-#include <cassert>
-#include <cstring>
-#include <memory>
-
-using namespace RouteBuilder;
-
-namespace {
-
-    //===------------------------------------------------------------------===//
-    // Helper Functions
-    //===------------------------------------------------------------------===//
-
-    [[gnu::always_inline]] constexpr static uint64_t packedU64FromString(const char* __restrict src, size_t start, size_t end) {
-        size_t len = end - start;
-        if (len > 8) len = 8;
-
-        uint64_t value = 0;
-
-        switch(len) {
-            case 8: value |= (uint64_t)(uint8_t)src[start+7] << 56; [[fallthrough]];
-            case 7: value |= (uint64_t)(uint8_t)src[start+6] << 48; [[fallthrough]];
-            case 6: value |= (uint64_t)(uint8_t)src[start+5] << 40; [[fallthrough]];
-            case 5: value |= (uint64_t)(uint8_t)src[start+4] << 32; [[fallthrough]];
-            case 4: value |= (uint64_t)(uint8_t)src[start+3] << 24; [[fallthrough]];
-            case 3: value |= (uint64_t)(uint8_t)src[start+2] << 16; [[fallthrough]];
-            case 2: value |= (uint64_t)(uint8_t)src[start+1] << 8; [[fallthrough]];
-            case 1: value |= (uint64_t)(uint8_t)src[start+0]; break;
-            default: break;
-        }
-
-        switch(len) {
-            case 0: value |= (uint64_t)0xFF << 0; [[fallthrough]];
-            case 1: value |= (uint64_t)0xFF << 8; [[fallthrough]];
-            case 2: value |= (uint64_t)0xFF << 16; [[fallthrough]];
-            case 3: value |= (uint64_t)0xFF << 24; [[fallthrough]];
-            case 4: value |= (uint64_t)0xFF << 32; [[fallthrough]];
-            case 5: value |= (uint64_t)0xFF << 40; [[fallthrough]];
-            case 6: value |= (uint64_t)0xFF << 48; [[fallthrough]];
-            case 7: value |= (uint64_t)0xFF << 56; break;
-            default: break;
-        }
-
-        return value;
-    }
-
-    inline static bool nodeStaticMatches(const std::shared_ptr<RouteNode>& node,
-                                                     const char* __restrict url,
-                                                     uint32_t* offset) {
-        uint64_t value_buffer = packedU64FromString(url, *offset, *offset + node->value_length);
-
-        return (value_buffer == node->value);
-    }
-
-    inline static constexpr char hex_to_char(char h) noexcept {
-        return (h >= '0' && h <= '9') ? (h - '0')
-             : (h >= 'A' && h <= 'F') ? (h - 'A' + 10)
-             : (h >= 'a' && h <= 'f') ? (h - 'a' + 10)
-             : 0;
-    }
-
-    inline static std::string url_decode(const char* __restrict start, const char* __restrict end) {
-        std::string out;
-        out.reserve(end - start);
-
-        const char* p = start;
-        while (p < end) {
-            char c = *p;
-            if (c == '%') {
-                if (p + 2 < end) {
-                    char hi = hex_to_char(*(p + 1));
-                    char lo = hex_to_char(*(p + 2));
-                    out.push_back((hi << 4) | lo);
-                    p += 3;
-                    continue;
-                }
-            } else if (c == '+') {
-                out.push_back(' ');
-                ++p;
-                continue;
-            }
-
-            out.push_back(c);
-            ++p;
-        }
-        return out;
-    }
-
-    inline static bool parse_query_params(
-        Napi::Env env,
-        const char* __restrict url,
-        uint32_t* __restrict offset,
-        Napi::Object* query_params,
-        uint32_t query_limit
-    ) noexcept
-    {
-        const char* p = url + *offset;
-
-        if (*p == '?') p++;
-
-        uint32_t scanned = 0;
-
-        const char* key_start = p;
-        const char* val_start = nullptr;
-
-        while (*p != '\0') {
-
-            // ---- LAST POINT CONTROLLERS ----
-            if (*p == ' ' || *p == '\r' || *p == '\n' || *p == '#') {
-                break;
-            }
-
-            scanned++;
-
-            if (scanned > query_limit) {
-                return false; // QUERY LIMIT EXCEEDED
-            }
-
-            if (*p == '=') {
-                val_start = p + 1;
-            }
-            else if (*p == '&') {
-
-                const char* key_end = val_start ? (val_start - 1) : p;
-                const char* val_end = val_start ? p : p;
-
-                auto key = url_decode(key_start, key_end);
-                auto value = val_start ? url_decode(val_start, val_end) : "";
-
-                query_params->Set(key, value);
-
-                key_start = p + 1;
-                val_start = nullptr;
-            }
-
-            p++;
-        }
-
-        if (key_start && key_start < p) {
-            const char* key_end = val_start ? (val_start - 1) : p;
-            const char* val_end = val_start ? p : p;
-
-            auto key = url_decode(key_start, key_end);
-            auto value = val_start ? url_decode(val_start, val_end) : "";
-
-            query_params->Set(key, value);
-        }
-
-        *offset += scanned;
-
-        return true;
-    }
-
-} // namespace
-
-
-//===----------------------------------------------------------------------===//
-// matchUrl Implementation
-//===----------------------------------------------------------------------===//
-int RouteBuilder::matchUrl(
-    Napi::Env env,
-    const std::shared_ptr<RouteNode>& root,
-    const char* url,
-    size_t urlLen,
-    uint32_t* offset,
-    Napi::Array* path_params,
-    Napi::Object* query_params,
-    uint32_t query_limit
-    ) noexcept
-{
-    auto node = root;
-
-    if (!node) return -1;
-
-    if (!node->is_param && node->value_length > 0) {
-        if (!nodeStaticMatches(node, url, offset)) {
-            return -1;
-        }
-        *offset += node->value_length;
-    }
-
-    uint32_t path_index = 0;
-    bool matched = false;
-    
-    while (true) {
-        matched = false;
-
-        #pragma clang loop vectorize(disable)
-        #pragma clang loop unroll(disable)
-        for (auto& child : node->children) {
-            if (!child) continue;
-            // Line caches Opt
-            // __builtin_prefetch(child.get(), 0, 1);
-
-            if (child->is_param) [[unlikely]] {
-                const char* p = url + *offset;
-                size_t start = *offset;
-
-                while (*p && *p != '/' && *p != '?' && *p != ' ') p++;
-                __builtin_assume(p >= url && p <= url + urlLen);
-
-                size_t param_len = p - (url + start);
-                std::string param_value(url + start, param_len);
-
-                path_params->Set(path_index++, Napi::String::New(env, param_value));
-                
-                *offset += param_len;
-                
-                node = child;
-                matched = true;
-
-                if (__builtin_expect((child->vptr_table_index != -1) && (url[*offset] == ' ' || url[*offset] == '?'), 1)) {
-                    if (url[*offset] == '?') {
-                        if (!parse_query_params(env, url, offset, query_params, query_limit)) return -2;
-                        *offset += 1;
-                    }
-                    return child->vptr_table_index;
-                }
-                *offset += 1;
-                break;
-            }
-            else [[likely]] {
-                if (child->is_wildcard) [[unlikely]] {
-                    #pragma clang loop vectorize(disable)
-                    #pragma clang loop unroll(disable)
-                    while (url[*offset] != ' ') {
-                        if (*offset > 1000) return -3;
-                        if (url[*offset] == '?') {
-                           if(!parse_query_params(env, url, offset, query_params, query_limit)) return -2;
-                           *offset += 1;
-                           break;
-                        }
-                        *offset += 1;
-                    }
-                    return child->vptr_table_index;
-                }
-
-                if (nodeStaticMatches(child, url, offset)) {
-                    *offset += child->value_length;
-
-                    node = child;
-                    matched = true;
-                    
-                    if (child->vptr_table_index != -1 && (url[*offset] == ' ' || url[*offset] == '?')) {
-                        // Parse Query
-                        if (url[*offset] == '?') {
-                           if(!parse_query_params(env, url, offset, query_params, query_limit)) return -2;
-                           *offset += 1;
-                        }
-                        return child->vptr_table_index;
-                    }
-                    break;
-                }
-            }
-        }
-
-        if (!matched) break;
-    }
-
-    return -1;
-}

package/native/http/routes/route_print.cpp

@@ -1,20 +0,0 @@
-#include <iostream>
-
-#include "route.h"
-
-void RouteBuilder::printRouteTree(const std::shared_ptr<RouteNode>& node, int depth) noexcept {
-    if (!node) return;
-    for (int i = 0; i < depth; ++i) std::cout << "  ";
-    if (node->is_param) {
-        std::cout << "PARAM(" << node->param_name << ")";
-    } else if (node->value_length > 0) {
-        std::cout << "STATIC(len=" << node->value_length << ", hex=" << std::hex << node->value << std::dec << ")";
-    } else {
-        std::cout << "ROOT";
-    }
-    if (node->vptr_table_index != -1)
-        std::cout << " -> ENDPOINT_IDX=" << node->vptr_table_index;
-    std::cout << "\n";
-
-    for (auto &c : node->children) printRouteTree(c, depth + 1);
-}

package/native/main.cpp

@@ -1,54 +0,0 @@
-#include <napi.h>
-
-#include "http_scanner.h"
-#include <asset_parser.h>
-#include <cpool.h>
-#include <asset_parser.h>
-
-inline const char* scan_url(
-    const char* __restrict curl,
-    uint32_t* __restrict offset
-) {
-    uint32_t i = *offset;
-    const char* url_start = curl + i;
-
-    while (true) {
-        char c = curl[i];
-
-        if (c == ' ' || c == '?') {
-            *offset = i;        
-            return url_start;
-        }
-        ++i;
-    }
-}
-
-Napi::Value ScanUrl(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-
-    if (info.Length() < 2 || !info[0].IsBuffer() || !info[1].IsNumber()) [[unlikely]] {
-        Napi::TypeError::New(env, "Expected (curl: Buffer, offset: number)").ThrowAsJavaScriptException();
-        return env.Undefined();
-    }
-
-    auto buf = info[0].As<Napi::Buffer<char>>();
-    const char* curl = buf.Data();
-    uint32_t offset = info[1].As<Napi::Number>().Uint32Value();
-
-    const char* url = scan_url(curl, &offset);
-
-    return Napi::String::New(env, url);
-}
-
-
-Napi::Object Init(Napi::Env env, Napi::Object exports) {
-    exports.Set("HttpCore", HttpCore::GetClass(env));
-    exports.Set("PublicAssetParser", PublicAssetParser::GetClass(env));
-    
-    exports.Set("scanUrl", Napi::Function::New(env, ScanUrl));
-
-    exports.Set("CPool", CPool::GetClass(env));
-    return exports;
-}
-
-NODE_API_MODULE(hypernode, Init)