Support for `*` as a valid path parameter

[BlankParticle]

What is the feature you are proposing?

This would be a part of #5106 as a new feature in Hono v5

Basically add support for properly typed wildcard * param in routes and we can access it via c.req.param(), its a better way to do /thing/:path{.*}

This test explains it the best

it('Should return wildcard parameters', async () => {
  const app = new Hono()
  app.get('/thing/*', (c) => c.json(c.req.param()))

  const res = await app.request('/thing/foo/bar')

  expect(await res.json()).toEqual({ '*': 'foo/bar' })
})

The API would look like

app.get('/thing/*', (c) => {
  c.req.param('*') // string
  c.req.param()    // { '*': string }
})

and you will use it like this

app.get('/thing/*', (c) => {
   const { '*': _splat } = c.req.param(); // _splat is what TanStack calls it, you can call it anything
   const _splat2 = c.req.param('*')
})

This is the behaviours I have in mind

Route pattern	Request path	Wildcard capture	Notes
/a/*	/a/b	b	The separating / is not part of the capture.
/a/*	/a/b/c	b/c	The capture may contain multiple path segments.
/a/*	/a/	""	Empty wildcard capture.
/a/*	/a	""	The trailing wildcard may match no additional path.
/a/*	/ab	No match	The wildcard is a distinct path segment.
/*	/a/b	a/b	Captures the entire path without the leading /.
*	/a/b	a/b	Captures the entire path without the leading /.
/a*	/a/b	No wildcard parameter	Invalid wildcard pattern
/a*	/abc	No wildcard parameter	Invalid wildcard pattern
/a/:path{.*}	/a/b/c	path = "b/c"	Existing named-regexp equivalent of /a/*.

[EdamAme-x]

this is a feature that also exists in frameworks like Elysia, and I've been wanting it for a long time

[heroboy]

What if there's two * in the pattern.

[BlankParticle]

What if there's two * in the pattern.

/** is technically not a supported pattern, it behaves like a wildcard but some routers have issues with it
see #4623
so I don't think we need to do anything with that pattern, we can just ignore it and let hono deal with it as it always has

[heroboy]

What if there's two * in the pattern.

/** is technically not a supported pattern, it behaves like a wildcard but some routers have issues with it see #4623 so I don't think we need to do anything with that pattern, we can just ignore it and let hono deal with it as it always has

I mean /a/*/b/*.

[BlankParticle]

double wildcard is a undocumented case, I am not sure what should happen with it

This test is verifying what you are asking about

it("should match double wildcard", async () => {
  const app = new Hono()
  app.get('/foo/*/bar/*', (c) => c.text(c.req.path))
  const res = await app.request('http://localhost/foo/1/2/bar/3/4');
  expect(await res.text()).toBe('/foo/1/2/bar/3/4')
})

and the results says, double wildcard is not handled properly

but

const res = await app.request('http://localhost/foo/1/bar/2/3');

this matches /foo/*/bar/* pattern, so the double wildcard behaviour in Hono is a undefined behaviour
every router I have seen only allows for single wildcard, so I would be curious to see if you have any example of a router that handles it properly and how they handle it

[heroboy]

No, I think * only matches a single segment of the URL path.

async function test()
{
	const app = new Hono();
	app.get('/a/*/b/*', c => c.text(c.req.path));
	assert.equal(await (await app.request('/a/x/b/z')).text(), '/a/x/b/z');
}

[BlankParticle]

No, I think * only matches a single segment of the URL path.

async function test()
{
const app = new Hono();
app.get('/a//b/', c => c.text(c.req.path));
assert.equal(await (await app.request('/a/x/b/z')).text(), '/a/x/b/z');
}

matching single segment isn't really an issue, for you example use case you can get away with /a/:param1/b/:param2, * is supposed to match multiple segments like I showed in the table

/a/*/b/* conceptually works like /a/:param/b/* where the first wildcard can only match a single segment, but its probably a undocumented behaviour

but yeah, I am not sure what should we do if a user tries to use /a/*/b/* as a match pattern, I think they will end up with the value of 2nd * in the param() function based on how we design this, as there is no spec and this is not a supported feature we can't really say what will happen

[heroboy]

hono/src/router/common.case.test.ts

Lines 299 to 306 in 44f8843

	describe('Duplicate param name', () => {
	it('self', () => {
	router.add('GET', '/:id/:id', 'foo')
	const res = match('GET', '/123/456')
	expect(res.length).toBe(1)
	expect(res[0].handler).toEqual('foo')
	expect(res[0].params['id']).toBe('123')
	})

Based on this test, it seems that when a parameter name is repeated, the first occurrence is the one that gets captured. So, to keep the behavior consistent, * shouldn't capture the last match either.

Also, looking at the pattern-router implementation, a trailing * is treated as a special case, whereas /* in the middle of a route matches only a single path segment("/[^/]+").

[BlankParticle]

I wasn't aware that repeated params would take take first value, I instinctively chose the last one as in case of wild card the multi segement capture ended up in the last one, but I agree that we should keep things consistent
about the * behaviour, thats interesting that it behaves differently in trailing cases than in the middle, I hadn't looked at the source code yet for figuring out the exact behaviours between different routers, thanks for bringing this up, I will review the behaviours and update the issue for the edge cases, what happens and how can we deal with them

[BlankParticle]

I made a patch for the wildcard behaviour I suggested here and tested against the current implementation betweeen all the routers that are included in Hono
here is the gist that includes the patch, script to compare the behaviours and results matrix https://gist.github.com/BlankParticle/cfd1994543d0e4507f6a88da649050f2