fix: preserve canonical listener keys when merging emitters

Author: cblanquera

src/emitter/EventEmitter.ts

@@ -177,10 +177,21 @@ export default class EventEmitter<M extends EventMap> {
         //skip
         continue;
       }
+      //listener keys are already canonical in the source emitter.
+      //Copy them directly so subclass on() overrides do not reinterpret
+      //regex-backed route keys as fresh event patterns during merge.
+      if (typeof this._listeners[event as keyof M] === 'undefined') {
+        this._listeners[event as keyof M] = new Set<TaskItem<M[keyof M]>>();
+      }
+      const listeners = this._listeners[event as keyof M] as Set<
+        TaskItem<M[keyof M]>
+      >;
       //then loop the tasks
       for (const { item, priority } of tasks) {
-        //listen to each task one by one
-        this.on(event, item, priority);
+        listeners.add({
+          item: item as TaskAction<M[keyof M]>,
+          priority
+        });
       }
     }
     return this;
@@ -213,4 +224,4 @@ export default class EventEmitter<M extends EventMap> {
       }
     };
   }
-}
+}

tests/RouteEmitter.test.ts

@@ -135,4 +135,30 @@ describe('RouteEmitter Tests', () => {
     expect(triggered).to.deep.equal(['/shared/test']);
     expect(router.routes.size).to.equal(0);
   });
+
+  it('should preserve canonical regex listener keys when merging parameterized routes', async () => {
+    const child = new Router<R, S>();
+    const parent = new Router<R, S>();
+    const event = '/^GET \\/users\\/([^/]+)\\/*$/g';
+    const malformed = '/^\\/^GET \\/users\\/([^/]+)\\/([^/]+)$\\/g$/g';
+    const triggered: string[] = [];
+
+    child.route('GET', '/users/:id', (req, res) => {
+      triggered.push(req.path);
+      res.body = 'matched';
+    });
+
+    parent.use(child);
+    const response = await parent.emit(
+      'GET /users/42',
+      { path: '/users/42' },
+      {}
+    );
+
+    expect(response.code).to.equal(200);
+    expect(triggered).to.deep.equal(['/users/42']);
+    expect(parent.listeners[event]).to.be.instanceOf(Set);
+    expect(parent.listeners[malformed]).to.be.undefined;
+    expect(Array.from(parent.expressions.keys())).to.deep.equal([event]);
+  });
 });

tests/Router.test.ts

@@ -129,4 +129,86 @@ describe('Router Tests', () => {
     }>;
     expect(Array.from(tasks.values())[1].item.name).to.equal('withName');
   })
-})
+
+  it('should preserve exact, parameterized, and fallback routes after use()', async () => {
+    const child = new Router<R, S>();
+    const parent = new Router<R, S>();
+    const triggered: string[] = [];
+
+    child.route('GET', '/', (_req, res) => {
+      triggered.push('root');
+      res.body = 'root';
+    });
+    child.route('GET', '/login', (_req, res) => {
+      triggered.push('login');
+      res.body = 'login';
+    });
+    child.route('GET', '/user', (_req, res) => {
+      triggered.push('user');
+      res.body = 'user';
+    });
+    child.route('GET', '/user/:id', (req, res) => {
+      triggered.push(`get:${req.data('id')}`);
+      res.body = `get:${req.data('id')}`;
+    });
+    child.route('PUT', '/user/:id', (req, res) => {
+      triggered.push(`put:${req.data('id')}`);
+      res.body = `put:${req.data('id')}`;
+    });
+    child.route('DELETE', '/user/:id', (req, res) => {
+      triggered.push(`delete:${req.data('id')}`);
+      res.body = `delete:${req.data('id')}`;
+    });
+    child.route('ANY', '/files/**', (_req, res) => {
+      triggered.push('wildcard');
+      res.body = 'fallback';
+    });
+
+    parent.use(child);
+
+    const rootReq = parent.request({ resource: { path: '/' } });
+    const rootRes = parent.response({ resource: {} });
+    await parent.emit('GET /', rootReq, rootRes);
+
+    const loginReq = parent.request({ resource: { path: '/login' } });
+    const loginRes = parent.response({ resource: {} });
+    await parent.emit('GET /login', loginReq, loginRes);
+
+    const userReq = parent.request({ resource: { path: '/user' } });
+    const userRes = parent.response({ resource: {} });
+    await parent.emit('GET /user', userReq, userRes);
+
+    const getReq = parent.request({ resource: { path: '/user/1' } });
+    const getRes = parent.response({ resource: {} });
+    await parent.emit('GET /user/1', getReq, getRes);
+
+    const putReq = parent.request({ resource: { path: '/user/1' } });
+    const putRes = parent.response({ resource: {} });
+    await parent.emit('PUT /user/1', putReq, putRes);
+
+    const deleteReq = parent.request({ resource: { path: '/user/1' } });
+    const deleteRes = parent.response({ resource: {} });
+    await parent.emit('DELETE /user/1', deleteReq, deleteRes);
+
+    const fallbackReq = parent.request({ resource: { path: '/files/missing/path' } });
+    const fallbackRes = parent.response({ resource: {} });
+    await parent.emit('PATCH /files/missing/path', fallbackReq, fallbackRes);
+
+    expect(triggered).to.deep.equal([
+      'root',
+      'login',
+      'user',
+      'get:1',
+      'put:1',
+      'delete:1',
+      'wildcard'
+    ]);
+    expect(rootRes.body).to.equal('root');
+    expect(loginRes.body).to.equal('login');
+    expect(userRes.body).to.equal('user');
+    expect(getRes.body).to.equal('get:1');
+    expect(putRes.body).to.equal('put:1');
+    expect(deleteRes.body).to.equal('delete:1');
+    expect(fallbackRes.body).to.equal('fallback');
+  });
+})