@esportsplus/routing 0.2.0 → 0.2.2

package/bench/index.mjs

@@ -0,0 +1,217 @@
+import { performance } from 'node:perf_hooks';
+import routerFactory from '../build/router/index.js';
+
+function fmt(n) {
+  return new Intl.NumberFormat('en-US').format(n);
+}
+
+function timeit(fn, durationMs = 1000) {
+  // Warmup
+  for (let i = 0; i < 5_000; i++) fn();
+
+  const end = performance.now() + durationMs;
+  let count = 0;
+  while (performance.now() < end) {
+    fn();
+    count++;
+  }
+  return count * (1000 / durationMs);
+}
+
+function buildStaticPaths(length, count) {
+  const paths = new Array(count);
+  for (let i = 0; i < count; i++) {
+    const id = i.toString(36).padStart(3, '0');
+    paths[i] = '/a'.repeat(length) + '/' + id;
+  }
+  return paths;
+}
+
+function buildDynamicPaths(length, count) {
+  // Route patterns
+  const patterns = new Array(count);
+  for (let i = 0; i < count; i++) {
+    patterns[i] = '/a'.repeat(length) + '/:id';
+  }
+  return patterns;
+}
+
+function buildDynamicTestPaths(length, count) {
+  // Concrete paths to match against dynamic patterns
+  const paths = new Array(count);
+  for (let i = 0; i < count; i++) {
+    const id = i.toString(36).padStart(3, '0');
+    paths[i] = '/a'.repeat(length) + '/' + id;
+  }
+  return paths;
+}
+
+function buildWildcardPatterns(length, count) {
+  // Unique patterns: /a.../<token>/*:rest
+  const patterns = new Array(count);
+  for (let i = 0; i < count; i++) {
+    const token = i.toString(36);
+    patterns[i] = '/a'.repeat(length) + '/' + token + '/*:rest';
+  }
+  return patterns;
+}
+
+function buildWildcardTestPaths(length, count, tailSegments = 4) {
+  // Concrete paths that should match the wildcard patterns above
+  const paths = new Array(count);
+  const tail = Array.from({ length: tailSegments }, (_, j) => 'x' + j).join('/');
+  for (let i = 0; i < count; i++) {
+    const token = i.toString(36);
+    paths[i] = '/a'.repeat(length) + '/' + token + '/' + tail;
+  }
+  return paths;
+}
+
+function buildOptionalPatterns(baseLen, optionalCount, count) {
+  // Unique patterns: /a.../<token>?:p1?:p2?...?:pN
+  const patterns = new Array(count);
+  for (let i = 0; i < count; i++) {
+    const token = i.toString(36);
+    let p = '/a'.repeat(baseLen) + '/' + token;
+    for (let k = 1; k <= optionalCount; k++) {
+      p += '?:p' + k;
+    }
+    patterns[i] = p;
+  }
+  return patterns;
+}
+
+function buildOptionalTestPaths(baseLen, optionalCount, count) {
+  // Concrete paths using the max number of optionals to exercise the longest route
+  const paths = new Array(count);
+  for (let i = 0; i < count; i++) {
+    const token = i.toString(36);
+    let p = '/a'.repeat(baseLen) + '/' + token;
+    for (let k = 1; k <= optionalCount; k++) {
+      p += '/' + 'v' + k;
+    }
+    paths[i] = p;
+  }
+  return paths;
+}
+
+function benchAdd(paths, { dynamic = false, resetEvery = 25000, uniquePath } = {}) {
+  let router = routerFactory();
+  const resp = (req) => 1;
+  let k = 0;
+  let unique = 0;
+
+  return timeit(() => {
+    // Generate a unique path to avoid duplicate key errors
+    const base = paths[k++ % paths.length];
+    const path = uniquePath
+      ? uniquePath(base, unique++)
+      : (dynamic ? (base + '/x' + (unique++)) : (base + '-' + (unique++)));
+    router.get({ path, responder: resp });
+
+    // Periodically reset to keep memory bounded
+    if (unique % resetEvery === 0) {
+      router = routerFactory();
+    }
+  });
+}
+
+function benchMatch(router, paths, { method = 'GET' } = {}) {
+  let k = 0;
+  return timeit(() => {
+    const path = paths[k++ % paths.length];
+    const { route } = router.match(method, path);
+    if (!route) throw new Error('route not found');
+  });
+}
+
+function prepareRouterStatic(paths) {
+  const router = routerFactory();
+  const resp = (req) => 1;
+  for (const p of paths) router.get({ path: p, responder: resp });
+  return router;
+}
+
+function prepareRouterDynamic(paths) {
+  const router = routerFactory();
+  const resp = (req) => 1;
+  for (const p of paths) router.get({ path: p, responder: resp });
+  return router;
+}
+
+function section(title) {
+  console.log('\n' + title);
+  console.log('-'.repeat(title.length));
+}
+
+(async function main() {
+  const lengths = [1, 2, 4, 8];
+  const poolSize = 1_000;
+
+  section('Add routes (ops/sec)');
+  for (const len of lengths) {
+    const staticPaths = buildStaticPaths(len, poolSize);
+    const dynamicPatterns = buildDynamicPaths(len, poolSize);
+
+    const addS = benchAdd(staticPaths);
+    const addD = benchAdd(dynamicPatterns, { dynamic: true });
+
+    console.log(`length=${len}  static_add=${fmt(addS)}  dynamic_add=${fmt(addD)}`);
+  }
+
+  section('Match routes (ops/sec)');
+  for (const len of lengths) {
+    const staticPaths = buildStaticPaths(len, poolSize);
+    const dynamicPatterns = buildDynamicPaths(len, poolSize);
+    const dynamicTestPaths = buildDynamicTestPaths(len, poolSize);
+
+    const routerS = prepareRouterStatic(staticPaths);
+    const routerD = prepareRouterDynamic(dynamicPatterns);
+
+    const matchS = benchMatch(routerS, staticPaths);
+    const matchD = benchMatch(routerD, dynamicTestPaths);
+
+    console.log(`length=${len}  static_match=${fmt(matchS)}  dynamic_match=${fmt(matchD)}`);
+  }
+
+  // Wildcard creation and matching
+  section('Wildcard routes (ops/sec)');
+  for (const len of lengths) {
+    const wildcardPatterns = buildWildcardPatterns(len, poolSize);
+    // For wildcard, uniqueness must be inserted before '/*:rest'
+    const addW = benchAdd(wildcardPatterns, {
+      dynamic: true,
+      uniquePath: (base, n) => {
+        const idx = base.indexOf('/*:rest');
+        return base.slice(0, idx) + '-u' + n + base.slice(idx);
+      },
+    });
+
+    const routerW = prepareRouterDynamic(wildcardPatterns);
+    const wildcardTests = buildWildcardTestPaths(len, poolSize, 8);
+    const matchW = benchMatch(routerW, wildcardTests);
+
+    console.log(`length=${len}  wildcard_add=${fmt(addW)}  wildcard_match=${fmt(matchW)}`);
+  }
+
+  // Optional parameter count scaling
+  section('Optional params scaling (ops/sec)');
+  const optionalCounts = [1, 2, 4, 8];
+  const baseLen = 2;
+  for (const nOpt of optionalCounts) {
+    const optPatterns = buildOptionalPatterns(baseLen, nOpt, poolSize);
+    const addO = benchAdd(optPatterns, {
+      dynamic: true,
+      uniquePath: (base, n) => {
+        const idx = base.indexOf('?:');
+        return idx === -1 ? (base + '-u' + n) : (base.slice(0, idx) + '-u' + n + base.slice(idx));
+      }
+    });
+
+    const routerO = prepareRouterDynamic(optPatterns);
+    const optTests = buildOptionalTestPaths(baseLen, nOpt, poolSize);
+    const matchO = benchMatch(routerO, optTests);
+
+    console.log(`optionals=${nOpt}  opt_add=${fmt(addO)}  opt_match=${fmt(matchO)}`);
+  }
+})();

package/build/router/index.js

@@ -1,8 +1,8 @@
-import { ON_DELETE, ON_GET, ON_POST, ON_PUT, STATIC } from '../constants.js';
+import { ON_DELETE, ON_GET, ON_POST, ON_PUT } from '../constants.js';
 import { Node } from './node.js';
 import pipeline from '@esportsplus/pipeline';
 function key(method, subdomain) {
-    return (method + (subdomain ? subdomain + ' ' : '')).toUpperCase();
+    return (method + (subdomain ? ' ' + subdomain : '')).toUpperCase();
 }
 function normalize(path) {
     if (path) {
@@ -42,12 +42,15 @@ class Router {
             root: new Node(),
             static: {}
         };
-        if (path.indexOf(':') === -1 || bucket.root.add(path, route).type === STATIC) {
+        if (path.indexOf(':') === -1) {
             if (path in bucket.static) {
                 throw new Error(`Routing: static path '${path}' is already in use`);
             }
             bucket.static[path] = route;
         }
+        else {
+            bucket.root.add(path, route);
+        }
         return this;
     }
     route(options) {

package/build/router/node.js

@@ -52,7 +52,7 @@ class Node {
             if (node.wildcard) {
                 wildcard = {
                     node: node.wildcard,
-                    value: segments.slice(i).join('/')
+                    start: i
                 };
             }
             let next = node.static?.get(segment);
@@ -69,7 +69,7 @@ class Node {
         }
         if ((node === undefined || node.route === null) && wildcard) {
             node = wildcard.node;
-            (parameters ??= {})[node.name] = wildcard.value;
+            (parameters ??= {})[node.name] = segments.slice(wildcard.start).join('/');
         }
         return {
             parameters,

package/package.json

@@ -3,7 +3,7 @@
   "dependencies": {
     "@esportsplus/pipeline": "^1.1.5",
     "@esportsplus/reactivity": "^0.12.4",
-    "@esportsplus/utilities": "^0.22.0"
+    "@esportsplus/utilities": "^0.22.1"
   },
   "devDependencies": {
     "@esportsplus/typescript": "^0.9.2"
@@ -14,7 +14,7 @@
   "type": "module",
   "sideEffects": false,
   "types": "./build/index.d.ts",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "scripts": {
     "build": "tsc && tsc-alias",
     "-": "-",

package/src/router/index.ts

@@ -1,11 +1,11 @@
-import { ON_DELETE, ON_GET, ON_POST, ON_PUT, STATIC } from '../constants';
+import { ON_DELETE, ON_GET, ON_POST, ON_PUT } from '../constants';
 import { Name, Options, Request, Route, RouteOptions } from '../types';
 import { Node } from './node';
 import pipeline from '@esportsplus/pipeline';
 
 
 function key(method: string, subdomain?: string | null) {
-    return (method + (subdomain ? subdomain + ' ' : '')).toUpperCase();
+    return (method + (subdomain ? ' ' + subdomain : '')).toUpperCase();
 }
 
 function normalize(path: string) {
@@ -57,13 +57,16 @@ class Router<T> {
                 static: {}
             };
 
-        if (path.indexOf(':') === -1 || bucket.root.add(path, route).type === STATIC) {
+        if (path.indexOf(':') === -1) {
             if (path in bucket.static) {
                 throw new Error(`Routing: static path '${path}' is already in use`);
             }
 
             bucket.static[path] = route;
         }
+        else {
+            bucket.root.add(path, route);
+        }
 
         return this;
     }

package/src/router/node.ts

@@ -30,7 +30,7 @@ class Node<T> {
             let segment = segments[i],
                 symbol = segment[0];
 
-            // Named name
+            // Parameter
             if (symbol === ':') {
                 if (!node.parameter) {
                     node.parameter = new Node<T>(node);
@@ -40,7 +40,7 @@ class Node<T> {
                 node = node.parameter;
                 type = PARAMETER;
             }
-            // "*:" Wildcard name
+            // "*:" Wildcard
             else if (symbol === '*') {
                 if (!node.wildcard) {
                     node.wildcard = new Node<T>(node);
@@ -77,7 +77,7 @@ class Node<T> {
         let node: Node<T> | undefined = this,
             parameters: Record<PropertyKey, unknown> | undefined,
             segments = path.split('/'),
-            wildcard: { node: Node<T>, value: string } | undefined;
+            wildcard: { node: Node<T>, start: number } | undefined;
 
         for (let i = 0, n = segments.length; i < n; i++) {
             let segment = segments[i];
@@ -85,7 +85,7 @@ class Node<T> {
             if (node.wildcard) {
                 wildcard = {
                     node: node.wildcard,
-                    value: segments.slice(i).join('/')
+                    start: i
                 };
             }
 
@@ -108,7 +108,7 @@ class Node<T> {
 
         if ((node === undefined || node.route === null) && wildcard) {
             node = wildcard.node;
-            (parameters ??= {})[ node.name! ] = wildcard.value;
+            (parameters ??= {})[ node.name! ] = segments.slice(wildcard.start).join('/');
         }
 
         return {