rax-radix-tree 1.0.1

package/benchmark/05.match-hosts.js

@@ -0,0 +1,25 @@
+
+const { benchmark, md5 } = require('./utility');
+const routeCount = 1000 * 1;
+const matchTimes = 1000 * 100;
+
+const path = "/12345";
+const routes = [];
+for (let i = 1; i <= routeCount; i++) {
+    routes.push({
+        paths: [path],
+        priority: i,
+        hosts: [md5(i.toString())],
+        meta: `hosts_${i}`
+    });
+}
+
+const middleValue = Math.floor(routeCount / 2).toString();
+const req = {
+    path: path,
+    headers: {
+        host: md5(middleValue)
+    }
+};
+
+benchmark("Match hosts", routeCount, matchTimes, routes, req);

package/benchmark/06.match-wildcard-hosts.js

@@ -0,0 +1,25 @@
+const { benchmark, md5 } = require('./utility');
+
+const routeCount = 1000 * 1;
+const matchTimes = 1000 * 100;
+
+const path = "/12345";
+const routes = [];
+for (let i = 1; i <= routeCount; i++) {
+    routes.push({
+        paths: [path],
+        priority: i,
+        hosts: [`*.${md5(i.toString())}`],
+        meta: `wildcard_hosts_${i}`
+    });
+}
+
+const middleValue = Math.floor(routeCount / 2).toString();
+const req = {
+    path: path,
+    headers: {
+        host: `1.${md5(middleValue)}`
+    }
+};
+
+benchmark("Match wildcard hosts", routeCount, matchTimes, routes, req);

package/benchmark/07.match-remote-address.js

@@ -0,0 +1,40 @@
+
+const { benchmark, md5 } = require('./utility');
+const routeCount = 1000 * 1;
+const matchTimes = 1000 * 1;
+const routes = [];
+
+function genRemoteAddr(i) {
+    return `127.0.${Math.floor(i / 256)}.${i % 256}`;
+}
+
+
+for (let i = 1; i <= routeCount; i++) {
+    routes.push({
+        paths: ["/admin/**"],
+        remoteAddrs: [`${genRemoteAddr(i)}`],
+        meta: { access: 'local' }
+    });
+}
+
+// Add a wildcard route
+routes.push({
+    paths: ["/**"],
+    meta: { access: 'public' }
+});
+
+const matchPath = "/admin/dashboard";
+
+const reqMatch = {
+    path: matchPath,
+    remoteAddr: genRemoteAddr(routeCount/2)
+};
+
+benchmark("Match remote address, route found", routeCount, matchTimes, routes, reqMatch);
+
+const reqNotMatch = {
+    path: matchPath,
+    remoteAddr: "192.168.1.1"
+};
+
+benchmark("Match remote address, route not found", routeCount, matchTimes, routes, reqNotMatch);

package/benchmark/08.match-exprs-headers.js

@@ -0,0 +1,50 @@
+const { benchmark, md5 } = require('./utility');
+const routeCount = 1000 * 1;
+const matchTimes = 1000 * 1;
+const routes = [];
+
+function genUserAgent(i) {
+    return md5(`useragent${i}`);
+}
+
+function genLanguage(i) {
+    return md5(`language${i}`);
+}
+
+for (let i = 1; i <= routeCount; i++) {
+    const userAgent = genUserAgent(i);
+    const language = genLanguage(i);
+    routes.push({
+        paths: ['/**'],
+        exprs: [`contains(user_agent, "${userAgent}") and accept_language == "${language}"`],
+        meta: { version: `v${i}` }
+    });
+}
+
+routes.push({
+    paths: ['/**'],
+    meta: { version: 'default' }
+});
+
+const matchPath = '/';
+
+const middleRoute = routes[Math.floor(routeCount / 2)];
+const reqMatch = {
+    path: matchPath,
+    headers: {
+        'user-agent': middleRoute.exprs[0].split('"')[1] + '/91.0.4472.124 Safari/537.36',
+        'accept-language': middleRoute.exprs[0].split('"')[3]
+    }
+};
+
+benchmark("Match expressions and headers, route found", routeCount, matchTimes, routes, reqMatch);
+
+const reqNotMatch = {
+    path: matchPath,
+    headers: {
+        'user-agent': 'curl/7.64.1',
+        'accept-language': 'fr-FR'
+    }
+};
+
+benchmark("Match expressions and headers, route not found", routeCount, matchTimes, routes, reqNotMatch);

package/benchmark/09.match-exprs-args.js

@@ -0,0 +1,50 @@
+const { benchmark, md5 } = require('./utility');
+const routeCount = 1000 * 1;
+const matchTimes = 1000 * 1;
+const routes = [];
+
+function genRandomCategory(i) {
+    return md5(i.toString());
+}
+
+function genRandomPrice() {
+    return Math.floor(Math.random() * 1000) + 1;
+}
+
+for (let i = 1; i <= routeCount; i++) {
+    const category = genRandomCategory(i);
+    const price = genRandomPrice();
+    routes.push({
+        paths: ["/products/**"],
+        exprs: [`category == "${category}" and price == ${price}`],
+        meta: { discount: '10%' }
+    });
+}
+
+routes.push({
+    paths: ["/products/**"],
+    meta: { discount: '0%' }
+});
+
+const matchPath = "/products/item";
+
+const middleRoute = routes[Math.floor(routeCount / 2)];
+const reqMatch = {
+    path: matchPath,
+    args: {
+        category: middleRoute.exprs[0].split('"')[1],
+        price: middleRoute.exprs[0].split('==')[2].trim()
+    }
+};
+
+benchmark("Match expressions and parameters, route found", routeCount, matchTimes, routes, reqMatch);
+
+const reqNotMatch = {
+    path: matchPath,
+    args: {
+        category: md5('nonexistent'),
+        price: '0'
+    }
+};
+
+benchmark("Match expressions and parameters, route not found", routeCount, matchTimes, routes, reqNotMatch);

package/benchmark/run.sh

@@ -0,0 +1,3 @@
+for file in benchmark/*.*.js; do
+    node "$file"
+done

package/benchmark/utility.js

@@ -0,0 +1,56 @@
+
+const { HttpRadixTree } = require('../index');
+const crypto = require('crypto');
+const profiler = require('v8-profiler-node8');
+
+function md5(input) {
+    return crypto.createHash('md5').update(input).digest('hex');
+}
+
+
+function benchmark(benchmarkName, routeCount, matchTimes, routes, req, profile=false) {
+    const rx = new HttpRadixTree(routes);
+
+    let res;
+    if (profile) {
+        profiler.startProfiling('findRoute', true);
+    }
+    const startTime = process.hrtime();
+    for (let i = 0; i < matchTimes; i++) {
+        res = rx.findRoute(req);
+    }
+    const [seconds, nanoseconds] = process.hrtime(startTime);
+    const duration = seconds * 1000 + nanoseconds / 1e6;
+    if (profile) {
+        var profileResult = profiler.stopProfiling();
+        var fs = require('fs');
+        profileResult.export(function(error, result) {
+            const currentTime = new Date().toLocaleString('zh-CN', { 
+                year: '2-digit', 
+                month: '2-digit', 
+                day: '2-digit', 
+                hour: '2-digit', 
+                minute: '2-digit', 
+                hour12: false 
+            }).replace(/[\/\s:]/g, '-').replace(',', '_');
+            const fileName = `profile_result_${benchmarkName.replace(/[\s,]+/g, '_')}_${currentTime}.json`;
+            console.log(`Writing profile result to file: ${fileName}`);
+            fs.writeFileSync(fileName, result);
+            profileResult.delete();
+        });
+    }
+
+    console.log(`## ${benchmarkName}`);
+    console.log("")
+    console.log("* Result:            ", res ? res.meta : null);
+    console.log("* Number of routes:  ", routeCount);
+    console.log("* Number of matches: ", matchTimes);
+    console.log("* Execution time:    ", duration.toFixed(0), "ms");
+    console.log("* QPS:               ", Math.floor(matchTimes / (duration / 1000)));
+    console.log("")
+}
+
+module.exports = {
+    benchmark,
+    md5
+};

package/binding.gyp

@@ -0,0 +1,14 @@
+{
+  "targets": [
+    {
+      "target_name": "rax_radix_tree",
+      "cflags!": [ "-fno-exceptions" ],
+      "cflags_cc!": [ "-fno-exceptions" ],
+      "sources": [ "src/rax_wrapper.cpp", "src/radix_tree.c", "src/rax/rax.c" ],
+      "include_dirs": [
+        "<!@(node -p \"require('node-addon-api').include\")"
+      ],
+      "defines": [ "NAPI_DISABLE_CPP_EXCEPTIONS" ]
+    }
+  ]
+}

package/http-radix-tree.js

@@ -0,0 +1,150 @@
+const { RadixTree } = require('./radix-tree');
+const { LRUCache } = require('lru-cache')
+const compileExpression = require('filtrex').compileExpression
+const { matches } = require('ip-matching');
+
+
+function contains(str, substr) {
+    return str.includes(substr)
+}
+
+function matchHosts(configHosts, requestHost) {
+    if (!requestHost) {
+        return false
+    }
+    const matched = configHosts.some(host => {
+        if (host.startsWith('*.')) {
+            const domain = host.slice(2)
+            return requestHost.endsWith(domain)
+        }
+        return host === requestHost
+    })
+
+    return matched
+}
+
+const cache = new LRUCache({
+    ttl: 1000 * 60,
+    max: 10000
+});
+
+
+function matchRemoteAddrs(configAddrs, requestIp) {
+    if (!requestIp) {
+        return false
+    }
+    if (!Array.isArray(configAddrs) || configAddrs.length === 0) {
+        return false;
+    }
+    const cacheKey = configAddrs.join(',') + ':' +  requestIp;
+    let matched = cache.get(cacheKey);
+    if (matched !== undefined) {
+        return matched
+    }
+    matched = configAddrs.some(addr => matches(requestIp, addr));
+    cache.set(cacheKey, matched)
+    return matched;
+}
+
+function matchExprs(compiledExprs, req) {
+    if (!Array.isArray(compiledExprs)) {
+        return false
+    }
+
+    const context = {
+        method: req.method,
+        path: req.path,
+    }
+    const tryParseNumber = (value) => {
+        if (typeof value === 'string') {
+            const num = Number(value);
+            return isNaN(num) ? value : num;
+        }
+        return value;
+    };
+    if (req.args) {
+        for (let key in req.args) {
+            key = key.toLowerCase()
+            context[key] = tryParseNumber(req.args[key])
+        }
+    }
+    if (req.headers) {
+        for (const [key, value] of Object.entries(req.headers)) {
+            const normalizedKey = key.toLowerCase().replace(/-/g, '_') // Replace - with _
+            context[normalizedKey] = tryParseNumber(value)
+        }
+    }
+
+    for (const { expr, compiledExpr } of compiledExprs) {
+        try {
+            const result = compiledExpr(context)
+            if (result instanceof Error) {
+                // console.info('matchExprs: eval expr %s with values(%s) error: %s', expr, JSON.stringify(context), result.message)
+                continue
+            }
+            if (result) {
+                return true
+            }
+        } catch (error) {
+            console.error('Error evaluating filter:', error)
+            return false
+        }
+    }
+
+    return false
+}
+
+function httpMatchRoute(route, req) {
+    // Check hosts
+    const host = req.headers ? req.headers.host : ''
+    if (route.hosts && route.hosts.length > 0 && !matchHosts(route.hosts, host)) {
+        return false
+    }
+
+    // Check remoteAddrs
+    if (route.remoteAddrs && route.remoteAddrs.length > 0
+        && !matchRemoteAddrs(route.remoteAddrs, req.remoteAddr)) {
+        return false
+    }
+
+    // Check exprs
+    if (route.compiledExprs && route.compiledExprs.length > 0
+        && !matchExprs(route.compiledExprs, req)) {
+        return false
+    }
+
+    return true
+}
+
+class HttpRadixTree extends RadixTree {
+    /**
+     * Creates a new HttpRadixTree instance
+     * 
+     * @param {Array} routes - Array of route configurations
+     * 
+     * Each route object should contain:
+     * @param {string|string[]} routes[].paths - Route path or array of paths
+     * @param {string|string[]} [routes[].methods] - HTTP method or array of methods
+     * @param {string[]} [routes[].hosts] - List of allowed hostnames, supports wildcards (e.g. *.example.com)
+     * @param {string[]} [routes[].remoteAddrs] - List of allowed remote IP addresses or CIDR ranges
+     * @param {string[]} [routes[].exprs] - List of filter expressions
+     * 
+     * The httpMatchRoute function is used to match routes:
+     * - Checks if the request's host matches routes[].hosts
+     * - Checks if the request's remoteAddr matches routes[].remoteAddrs
+     * - Evaluates all expressions in routes[].compiledExprs
+     */
+    constructor(routes) {
+        for (const route of routes) {
+            const exprs = route.exprs || [];
+            const compiledExprs = exprs.map(expr => ({
+                expr,
+                compiledExpr: compileExpression(expr, {extraFunctions: {contains}}),
+            }));
+            route.compiledExprs = compiledExprs;
+        }
+        super(routes, httpMatchRoute);
+    }
+}
+
+exports.HttpRadixTree = HttpRadixTree;

package/index.js

@@ -0,0 +1,5 @@
+const { RadixTree } = require('./radix-tree');
+const { HttpRadixTree } = require('./http-radix-tree');
+
+exports.RadixTree = RadixTree
+exports.HttpRadixTree = HttpRadixTree

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "rax-radix-tree",
+  "version": "1.0.1",
+  "description": "Node.js binding for rax, a radix tree implementation in ANSI C (https://github.com/antirez/rax)",
+  "author": "igeeky.io@gmail.com",
+  "license": "MIT",
+  "main": "index.js",
+  "scripts": {
+    "install": "node-gyp rebuild",
+    "test": "mocha ./test/*.test.js"
+  },
+  "keywords": [
+    "radix tree",
+    "rax",
+    "radix",
+    "tree",
+    "prefix",
+    "suffix",
+    "path matching"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/igeeky/rax-radix-tree.git"
+  },
+  "homepage": "https://github.com/igeeky/rax-radix-tree",
+  "dependencies": {
+    "filtrex": "^3.0.0",
+    "ip-matching": "^2.1.2",
+    "lru-cache": "^11.0.1",
+    "node-addon-api": "^8.1.0"
+  },
+  "devDependencies": {
+    "v8-profiler-node8": "^6.4.0",
+    "mocha": "^10.2.0",
+    "nyc": "^17.1.0"
+  },
+  "packageManager": "pnpm@9.9.0+sha512.60c18acd138bff695d339be6ad13f7e936eea6745660d4cc4a776d5247c540d0edee1a563695c183a66eb917ef88f2b4feb1fc25f32a7adcadc7aaf3438e99c1"
+}