fix(reg-exp-router): support line terminators in route paths for v5 (#5547)

* fix(reg-exp-router): match line terminators in RegExpRouter wildcards

* fix(reg-exp-router): keep line terminators in dynamic route paths

Author: usualoma

src/router/common.case.test.ts

@@ -11,6 +11,8 @@ const getSuiteHierarchy = (suite?: RunnerTestSuite) => {
   return res
 }
 
+const lineTerminators = ['\n', '\r', '\u2028', '\u2029']
+
 export const runTest = ({
   skip = [],
   newRouter,
@@ -237,6 +239,11 @@ export const runTest = ({
         expect(res.length).toBe(0)
       })
 
+      it.each(lineTerminators)('Regexp dot does not match %j', (char) => {
+        router.add('GET', '/:id{.+}', 'pattern')
+        expect(match('GET', `/a${char}b`)).toEqual([])
+      })
+
       it('Parameter with {.*} regexp', () => {
         router.add('GET', '/files/:name{.*}', 'file')
         let res = match('GET', '/files')
@@ -454,6 +461,10 @@ export const runTest = ({
         expect(res[2].handler).toEqual('/x')
         expect(res[3].handler).toEqual('/x/*')
       })
+
+      it.each(lineTerminators)('Matches a line terminator %j', (char) => {
+        expect(match('GET', `/a${char}b`).map(({ handler }) => handler)).toEqual(['/*', '*'])
+      })
     })
 
     describe('Suffix wildcard', () => {
@@ -516,6 +527,10 @@ export const runTest = ({
         const res = match('GET', '/pathfoo')
         expect(res.length).toBe(0)
       })
+
+      it.each(lineTerminators)('Matches a line terminator %j', (char) => {
+        expect(match('GET', `/path/a${char}b`)).toEqual([{ handler: 'path', params: {} }])
+      })
     })
 
     describe('Trailing wildcard after a label', () => {
@@ -956,6 +971,16 @@ export const runTest = ({
         expect(res[1].handler).toEqual('get () name')
         expect(res[1].params['name']).toEqual('hono')
       })
+
+      it.each(lineTerminators)('line terminator %j', (char) => {
+        router.add('ALL', `/a${char}b/*`, 'middleware')
+        router.add('GET', `/a${char}b/:name`, 'get name')
+        expect(match('GET', `/a${char}b/hono`)).toEqual([
+          { handler: 'middleware', params: {} },
+          { handler: 'get name', params: { name: 'hono' } },
+        ])
+        expect(match('GET', '/ab/hono')).toEqual([])
+      })
     })
 
     describe('REST API', () => {

src/router/reg-exp-router/node.ts

@@ -1,9 +1,10 @@
 import { createNullObject } from '../utils'
 
 export const LABEL_REG_EXP_STR = '[^/]+'
-export const ONLY_WILDCARD_REG_EXP_STR = '.*'
+// Match line terminators without changing the flags of user-defined parameter patterns.
+export const ONLY_WILDCARD_REG_EXP_STR = '[^]*'
 const PREFIXED_WILDCARD_REG_EXP_STR = '[^/]*'
-export const TAIL_WILDCARD_REG_EXP_STR = '(?:|/.*)'
+export const TAIL_WILDCARD_REG_EXP_STR = '(?:|/[^]*)'
 export const PATH_ERROR = Symbol()
 
 export type ParamAssocArray = [string, number][]
@@ -28,7 +29,7 @@ function compareKey(a: string, b: string): number {
     return 1
   }
 
-  // wildcard: the only wildcard (.*) precedes the tail wildcard
+  // wildcard: the only wildcard precedes the tail wildcard
   if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) {
     return b === TAIL_WILDCARD_REG_EXP_STR ? -1 : 1
   } else if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) {
@@ -74,7 +75,7 @@ export class Node {
                   : ['', '', PREFIXED_WILDCARD_REG_EXP_STR] // 'x*' may take nothing
             : null
           : token === '/*'
-            ? ['', '', TAIL_WILDCARD_REG_EXP_STR] // '/path/to/*' is /\/path\/to(?:|/.*)$
+            ? ['', '', TAIL_WILDCARD_REG_EXP_STR] // '/path/to/*' also matches '/path/to'
             : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/)
 
       let nextNode: Node

src/router/reg-exp-router/prepared-router.test.ts

@@ -122,7 +122,7 @@ describe('buildInitParams() and serializeInitParams()', () => {
     })
     expect(params).toEqual([
       {
-        [METHOD_NAME_ALL]: [/^.*$()/, [0, []], {}],
+        [METHOD_NAME_ALL]: [/^[^]*$()/, [0, []], {}],
       },
       {},
     ])
@@ -136,7 +136,7 @@ describe('buildInitParams() and serializeInitParams()', () => {
     expect(params).toEqual([
       {
         [METHOD_NAME_ALL]: [
-          /^(?:\/hello\/([^/]+)(?:$()|\/posts\/([^/]+)$())|.*$())/,
+          /^(?:\/hello\/([^/]+)(?:$()|\/posts\/([^/]+)$())|[^]*$())/,
           [0, 0, [], 0, [], []],
           {
             '/hello': [[], []],

src/router/reg-exp-router/router.test.ts

@@ -1,6 +1,7 @@
 import type { ParamIndexMap, ParamStash } from '../../router'
 import { UnsupportedPathError } from '../../router'
 import { runTest } from '../common.case.test'
+import { ONLY_WILDCARD_REG_EXP_STR, TAIL_WILDCARD_REG_EXP_STR } from './node'
 import { RegExpRouter } from './router'
 
 describe('RegExpRouter', () => {
@@ -176,15 +177,21 @@ describe('RegExpRouter', () => {
     })
 
     describe('Pattern that matches an empty string', () => {
-      it.each(['/api/:id{[0-9]?}', '/user/:id{[0-9]*}', '/:id{(?:a|)}', '/:id{a{0,3}}'])(
-        '%s',
-        (path) => {
-          const router = new RegExpRouter<string>()
-          expect(() => {
-            router.add('GET', path, 'ok')
-          }).toThrowError(UnsupportedPathError)
-        }
-      )
+      it.each([
+        '/api/:id{[0-9]?}',
+        '/user/:id{[0-9]*}',
+        '/:id{(?:a|)}',
+        '/:id{a{0,3}}',
+        `/:id{${ONLY_WILDCARD_REG_EXP_STR}}`,
+        `/:id{(?:${ONLY_WILDCARD_REG_EXP_STR})}`,
+        `/:id{${TAIL_WILDCARD_REG_EXP_STR}}`,
+        `/:id{(?:${TAIL_WILDCARD_REG_EXP_STR})}`,
+      ])('%s', (path) => {
+        const router = new RegExpRouter<string>()
+        expect(() => {
+          router.add('GET', path, 'ok')
+        }).toThrowError(UnsupportedPathError)
+      })
 
       it('Should still accept a pattern that requires at least one character', () => {
         const router = new RegExpRouter<string>()
@@ -199,6 +206,20 @@ describe('RegExpRouter', () => {
     })
   })
 
+  it.each([
+    ['[^]+', 'a\nb'],
+    ['(?:/[^]+)', '/a\nb'],
+  ])('Should extract parameters when the pattern is %s', (pattern, value) => {
+    const router = new RegExpRouter<string>()
+    router.add('GET', `/:value{${pattern}}/foo/:id`, 'handler')
+
+    const [res, stash] = router.match('GET', `/${value}/foo/end`)
+    const params = res[0][1] as ParamIndexMap
+    expect(res[0][0]).toBe('handler')
+    expect((stash as ParamStash)[params.value]).toBe(value)
+    expect((stash as ParamStash)[params.id]).toBe('end')
+  })
+
   describe('Wildcard after label', () => {
     it('Should be able to add a tail wildcard after a label', () => {
       const router = new RegExpRouter<string>()

src/router/reg-exp-router/trie.ts

@@ -41,7 +41,7 @@ export class Trie {
      *  - /* wildcard
      *  - character
      */
-    const tokens = markedPath.match(/(?::[^\/]+)|(?:\/\*$)|./g) || []
+    const tokens = markedPath.match(/(?::[^\/]+)|(?:\/\*$)|./gs) || []
     for (let i = groups.length - 1; i >= 0; i--) {
       const [mark] = groups[i]
       for (let j = tokens.length - 1; j >= 0; j--) {