@mswjs/interceptors 0.25.1 → 0.25.3

package/lib/node/presets/node.js

@@ -1,18 +1,19 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunk3MYUI4B2js = require('../chunk-3MYUI4B2.js');
+var _chunkNCHFM2TBjs = require('../chunk-NCHFM2TB.js');
 
 
-var _chunkE6YC337Qjs = require('../chunk-E6YC337Q.js');
+var _chunkJCWVLTP7js = require('../chunk-JCWVLTP7.js');
 require('../chunk-3LFH2WCF.js');
+require('../chunk-OGN3ZR35.js');
 require('../chunk-VQ4DZOBB.js');
-require('../chunk-ZJOF5MEZ.js');
-require('../chunk-XYZRP5S2.js');
+require('../chunk-5PTPJLB7.js');
+require('../chunk-3XFLRXRY.js');
 
 // src/presets/node.ts
 var node_default = [
-  new (0, _chunk3MYUI4B2js.ClientRequestInterceptor)(),
-  new (0, _chunkE6YC337Qjs.XMLHttpRequestInterceptor)()
+  new (0, _chunkNCHFM2TBjs.ClientRequestInterceptor)(),
+  new (0, _chunkJCWVLTP7js.XMLHttpRequestInterceptor)()
 ];
 
 

package/lib/node/presets/node.mjs

@@ -1,13 +1,14 @@
 import {
   ClientRequestInterceptor
-} from "../chunk-OL7OR4RL.mjs";
+} from "../chunk-MCO3RLQC.mjs";
 import {
   XMLHttpRequestInterceptor
-} from "../chunk-HSCXCLVT.mjs";
+} from "../chunk-FB53TMYN.mjs";
 import "../chunk-7II4SWKS.mjs";
+import "../chunk-3IYIKC3X.mjs";
 import "../chunk-GFH37L5D.mjs";
-import "../chunk-STA6QBYM.mjs";
-import "../chunk-RGYCLCLK.mjs";
+import "../chunk-YQGTMMOZ.mjs";
+import "../chunk-GM3YBSM3.mjs";
 
 // src/presets/node.ts
 var node_default = [

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mswjs/interceptors",
   "description": "Low-level HTTP/HTTPS/XHR/fetch request interception library.",
-  "version": "0.25.1",
+  "version": "0.25.3",
   "main": "./lib/node/index.js",
   "module": "./lib/node/index.mjs",
   "types": "./lib/node/index.d.ts",
@@ -128,7 +128,7 @@
     "@open-draft/until": "^2.0.0",
     "is-node-process": "^1.2.0",
     "outvariant": "^1.2.1",
-    "strict-event-emitter": "^0.5.0"
+    "strict-event-emitter": "^0.5.1"
   },
   "resolutions": {
     "memfs": "^3.4.13"

package/src/BatchInterceptor.test.ts

@@ -112,3 +112,144 @@ it('disposes of child interceptors', async () => {
   expect(primaryDisposeSpy).toHaveBeenCalledTimes(1)
   expect(secondaryDisposeSpy).toHaveBeenCalledTimes(1)
 })
+
+it('forwards listeners added via "on()"', () => {
+  class FirstInterceptor extends Interceptor<any> {
+    constructor() {
+      super(Symbol('first'))
+    }
+  }
+  class SecondaryInterceptor extends Interceptor<any> {
+    constructor() {
+      super(Symbol('second'))
+    }
+  }
+
+  const firstInterceptor = new FirstInterceptor()
+  const secondInterceptor = new SecondaryInterceptor()
+
+  const interceptor = new BatchInterceptor({
+    name: 'batch',
+    interceptors: [firstInterceptor, secondInterceptor],
+  })
+
+  const listener = vi.fn()
+  interceptor.on('foo', listener)
+
+  expect(firstInterceptor['emitter'].listenerCount('foo')).toBe(1)
+  expect(secondInterceptor['emitter'].listenerCount('foo')).toBe(1)
+  expect(interceptor['emitter'].listenerCount('foo')).toBe(0)
+})
+
+it('forwards listeners removal via "off()"', () => {
+  type Events = {
+    foo: []
+  }
+
+  class FirstInterceptor extends Interceptor<Events> {
+    constructor() {
+      super(Symbol('first'))
+    }
+  }
+  class SecondaryInterceptor extends Interceptor<Events> {
+    constructor() {
+      super(Symbol('second'))
+    }
+  }
+
+  const firstInterceptor = new FirstInterceptor()
+  const secondInterceptor = new SecondaryInterceptor()
+
+  const interceptor = new BatchInterceptor({
+    name: 'batch',
+    interceptors: [firstInterceptor, secondInterceptor],
+  })
+
+  const listener = vi.fn()
+  interceptor.on('foo', listener)
+  interceptor.off('foo', listener)
+
+  expect(firstInterceptor['emitter'].listenerCount('foo')).toBe(0)
+  expect(secondInterceptor['emitter'].listenerCount('foo')).toBe(0)
+})
+
+it('forwards removal of all listeners by name via ".removeAllListeners()"', () => {
+  type Events = {
+    foo: []
+    bar: []
+  }
+
+  class FirstInterceptor extends Interceptor<Events> {
+    constructor() {
+      super(Symbol('first'))
+    }
+  }
+  class SecondaryInterceptor extends Interceptor<Events> {
+    constructor() {
+      super(Symbol('second'))
+    }
+  }
+
+  const firstInterceptor = new FirstInterceptor()
+  const secondInterceptor = new SecondaryInterceptor()
+
+  const interceptor = new BatchInterceptor({
+    name: 'batch',
+    interceptors: [firstInterceptor, secondInterceptor],
+  })
+
+  const listener = vi.fn()
+  interceptor.on('foo', listener)
+  interceptor.on('foo', listener)
+  interceptor.on('bar', listener)
+
+  expect(firstInterceptor['emitter'].listenerCount('foo')).toBe(2)
+  expect(secondInterceptor['emitter'].listenerCount('foo')).toBe(2)
+  expect(firstInterceptor['emitter'].listenerCount('bar')).toBe(1)
+  expect(secondInterceptor['emitter'].listenerCount('bar')).toBe(1)
+
+  interceptor.removeAllListeners('foo')
+
+  expect(firstInterceptor['emitter'].listenerCount('foo')).toBe(0)
+  expect(secondInterceptor['emitter'].listenerCount('foo')).toBe(0)
+  expect(firstInterceptor['emitter'].listenerCount('bar')).toBe(1)
+  expect(secondInterceptor['emitter'].listenerCount('bar')).toBe(1)
+})
+
+it('forwards removal of all listeners via ".removeAllListeners()"', () => {
+  class FirstInterceptor extends Interceptor<any> {
+    constructor() {
+      super(Symbol('first'))
+    }
+  }
+  class SecondaryInterceptor extends Interceptor<any> {
+    constructor() {
+      super(Symbol('second'))
+    }
+  }
+
+  const firstInterceptor = new FirstInterceptor()
+  const secondInterceptor = new SecondaryInterceptor()
+
+  const interceptor = new BatchInterceptor({
+    name: 'batch',
+    interceptors: [firstInterceptor, secondInterceptor],
+  })
+
+  const listener = vi.fn()
+  interceptor.on('foo', listener)
+  interceptor.on('foo', listener)
+  interceptor.on('bar', listener)
+
+  expect(firstInterceptor['emitter'].listenerCount('foo')).toBe(2)
+  expect(secondInterceptor['emitter'].listenerCount('foo')).toBe(2)
+  expect(firstInterceptor['emitter'].listenerCount('bar')).toBe(1)
+  expect(secondInterceptor['emitter'].listenerCount('bar')).toBe(1)
+
+  interceptor.removeAllListeners()
+
+  expect(firstInterceptor['emitter'].listenerCount('foo')).toBe(0)
+  expect(secondInterceptor['emitter'].listenerCount('foo')).toBe(0)
+  expect(firstInterceptor['emitter'].listenerCount('bar')).toBe(0)
+  expect(secondInterceptor['emitter'].listenerCount('bar')).toBe(0)
+})

package/src/BatchInterceptor.ts

@@ -1,5 +1,5 @@
 import { EventMap, Listener } from 'strict-event-emitter'
-import { ExtractEventNames, Interceptor } from './Interceptor'
+import { Interceptor, ExtractEventNames } from './Interceptor'
 
 export interface BatchInterceptorOptions<
   InterceptorList extends ReadonlyArray<Interceptor<any>>
@@ -51,11 +51,45 @@ export class BatchInterceptor<
   public on<EventName extends ExtractEventNames<Events>>(
     event: EventName,
     listener: Listener<Events[EventName]>
-  ) {
+  ): this {
     // Instead of adding a listener to the batch interceptor,
     // propagate the listener to each of the individual interceptors.
-    this.interceptors.forEach((interceptor) => {
+    for (const interceptor of this.interceptors) {
       interceptor.on(event, listener)
-    })
+    }
+
+    return this
+  }
+
+  public once<EventName extends ExtractEventNames<Events>>(
+    event: EventName,
+    listener: Listener<Events[EventName]>
+  ): this {
+    for (const interceptor of this.interceptors) {
+      interceptor.once(event, listener)
+    }
+
+    return this
+  }
+
+  public off<EventName extends ExtractEventNames<Events>>(
+    event: EventName,
+    listener: Listener<Events[EventName]>
+  ): this {
+    for (const interceptor of this.interceptors) {
+      interceptor.off(event, listener)
+    }
+
+    return this
+  }
+
+  public removeAllListeners<EventName extends ExtractEventNames<Events>>(
+    event?: EventName | undefined
+  ): this {
+    for (const interceptors of this.interceptors) {
+      interceptors.removeAllListeners(event)
+    }
+
+    return this
   }
 }

package/src/Interceptor.test.ts

@@ -18,6 +18,52 @@ it('does not set a maximum listeners limit', () => {
   expect(interceptor['emitter'].getMaxListeners()).toBe(0)
 })
 
+describe('on()', () => {
+  it('adds a new listener using "on()"', () => {
+    const interceptor = new Interceptor(symbol)
+    expect(interceptor['emitter'].listenerCount('event')).toBe(0)
+
+    const listener = vi.fn()
+    interceptor.on('event', listener)
+    expect(interceptor['emitter'].listenerCount('event')).toBe(1)
+  })
+})
+
+describe('once()', () => {
+  it('calls the listener only once', () => {
+    const interceptor = new Interceptor(symbol)
+    const listener = vi.fn()
+
+    interceptor.once('foo', listener)
+    expect(listener).not.toHaveBeenCalled()
+
+    interceptor['emitter'].emit('foo', 'bar')
+
+    expect(listener).toHaveBeenCalledTimes(1)
+    expect(listener).toHaveBeenCalledWith('bar')
+
+    listener.mockReset()
+
+    interceptor['emitter'].emit('foo', 'baz')
+    interceptor['emitter'].emit('foo', 'xyz')
+    expect(listener).toHaveBeenCalledTimes(0)
+  })
+})
+
+describe('off()', () => {
+  it('removes a listener using "off()"', () => {
+    const interceptor = new Interceptor(symbol)
+    expect(interceptor['emitter'].listenerCount('event')).toBe(0)
+
+    const listener = vi.fn()
+    interceptor.on('event', listener)
+    expect(interceptor['emitter'].listenerCount('event')).toBe(1)
+
+    interceptor.off('event', listener)
+    expect(interceptor['emitter'].listenerCount('event')).toBe(0)
+  })
+})
+
 describe('persistence', () => {
   it('stores global reference to the applied interceptor', () => {
     const interceptor = new Interceptor(symbol)

package/src/Interceptor.ts

@@ -1,6 +1,5 @@
 import { Logger } from '@open-draft/logger'
-import { Listener } from 'strict-event-emitter'
-import { AsyncEventEmitter } from './utils/AsyncEventEmitter'
+import { Emitter, EventMap, Listener } from 'strict-event-emitter'
 
 export type InterceptorEventMap = Record<string, any>
 export type InterceptorSubscription = () => void
@@ -34,7 +33,7 @@ export type ExtractEventNames<Events extends Record<string, any>> =
   Events extends Record<infer EventName, any> ? EventName : never
 
 export class Interceptor<Events extends InterceptorEventMap> {
-  protected emitter: AsyncEventEmitter<Events>
+  protected emitter: Emitter<Events>
   protected subscriptions: Array<InterceptorSubscription>
   protected logger: Logger
 
@@ -43,7 +42,7 @@ export class Interceptor<Events extends InterceptorEventMap> {
   constructor(private readonly symbol: symbol) {
     this.readyState = InterceptorReadyState.INACTIVE
 
-    this.emitter = new AsyncEventEmitter()
+    this.emitter = new Emitter()
     this.subscriptions = []
     this.logger = new Logger(symbol.description!)
 
@@ -84,12 +83,6 @@ export class Interceptor<Events extends InterceptorEventMap> {
 
     this.readyState = InterceptorReadyState.APPLYING
 
-    // Always activate the emitter when applying the interceptor.
-    // This will ensure the interceptor can process events after it's
-    // been disposed and re-applied again (it may be a singleton).
-    this.emitter.activate()
-    logger.info('activated the emiter!', this.emitter.readyState)
-
     // Whenever applying a new interceptor, check if it hasn't been applied already.
     // This enables to apply the same interceptor multiple times, for example from a different
     // interceptor, only proxying events but keeping the stubs in a single place.
@@ -112,6 +105,8 @@ export class Interceptor<Events extends InterceptorEventMap> {
           runningInstance.emitter.removeListener(event, listener)
           logger.info('removed proxied "%s" listener!', event)
         })
+
+        return this
       }
 
       this.readyState = InterceptorReadyState.APPLIED
@@ -141,9 +136,9 @@ export class Interceptor<Events extends InterceptorEventMap> {
    * Listen to the interceptor's public events.
    */
   public on<EventName extends ExtractEventNames<Events>>(
-    eventName: EventName,
+    event: EventName,
     listener: Listener<Events[EventName]>
-  ): void {
+  ): this {
     const logger = this.logger.extend('on')
 
     if (
@@ -151,12 +146,36 @@ export class Interceptor<Events extends InterceptorEventMap> {
       this.readyState === InterceptorReadyState.DISPOSED
     ) {
       logger.info('cannot listen to events, already disposed!')
-      return
+      return this
     }
 
-    logger.info('adding "%s" event listener:', eventName, listener.name)
+    logger.info('adding "%s" event listener:', event, listener.name)
+
+    this.emitter.on(event, listener)
+    return this
+  }
+
+  public once<EventName extends ExtractEventNames<Events>>(
+    event: EventName,
+    listener: Listener<Events[EventName]>
+  ): this {
+    this.emitter.once(event, listener)
+    return this
+  }
+
+  public off<EventName extends ExtractEventNames<Events>>(
+    event: EventName,
+    listener: Listener<Events[EventName]>
+  ): this {
+    this.emitter.off(event, listener)
+    return this
+  }
 
-    this.emitter.on(eventName, listener)
+  public removeAllListeners<EventName extends ExtractEventNames<Events>>(
+    event?: EventName
+  ): this {
+    this.emitter.removeAllListeners(event)
+    return this
   }
 
   /**
@@ -196,7 +215,7 @@ export class Interceptor<Events extends InterceptorEventMap> {
       logger.info('disposed of all subscriptions!', this.subscriptions.length)
     }
 
-    this.emitter.deactivate()
+    this.emitter.removeAllListeners()
     logger.info('destroyed the listener!')
 
     this.readyState = InterceptorReadyState.DISPOSED

package/src/RemoteHttpInterceptor.ts

@@ -5,6 +5,7 @@ import { BatchInterceptor } from './BatchInterceptor'
 import { ClientRequestInterceptor } from './interceptors/ClientRequest'
 import { XMLHttpRequestInterceptor } from './interceptors/XMLHttpRequest'
 import { toInteractiveRequest } from './utils/toInteractiveRequest'
+import { emitAsync } from './utils/emitAsync'
 
 export interface SerializedRequest {
   id: string
@@ -166,20 +167,21 @@ export class RemoteHttpResolver extends Interceptor<HttpRequestEventMap> {
         body: requestJson.body,
       })
 
-      const interactiveRequest = toInteractiveRequest(capturedRequest)
+      const { interactiveRequest, requestController } =
+        toInteractiveRequest(capturedRequest)
 
-      this.emitter.emit('request', {
+      this.emitter.once('request', () => {
+        if (requestController.responsePromise.state === 'pending') {
+          requestController.respondWith(undefined)
+        }
+      })
+
+      await emitAsync(this.emitter, 'request', {
         request: interactiveRequest,
         requestId: requestJson.id,
       })
 
-      await this.emitter.untilIdle(
-        'request',
-        ({ args: [{ requestId: pendingRequestId }] }) => {
-          return pendingRequestId === requestJson.id
-        }
-      )
-      const [mockedResponse] = await interactiveRequest.respondWith.invoked()
+      const mockedResponse = await requestController.responsePromise
 
       if (!mockedResponse) {
         return

package/src/interceptors/ClientRequest/NodeClientRequest.test.ts

@@ -1,13 +1,13 @@
 import { vi, it, expect, beforeAll, afterAll } from 'vitest'
 import express from 'express'
 import { IncomingMessage } from 'http'
+import { Emitter } from 'strict-event-emitter'
 import { Logger } from '@open-draft/logger'
 import { HttpServer } from '@open-draft/test-server/http'
 import { DeferredPromise } from '@open-draft/deferred-promise'
 import { NodeClientRequest } from './NodeClientRequest'
 import { getIncomingMessageBody } from './utils/getIncomingMessageBody'
 import { normalizeClientRequestArgs } from './utils/normalizeClientRequestArgs'
-import { AsyncEventEmitter } from '../../utils/AsyncEventEmitter'
 import { sleep } from '../../../test/helpers'
 import { HttpRequestEventMap } from '../../glossary'
 
@@ -37,7 +37,7 @@ afterAll(async () => {
 })
 
 it('gracefully finishes the request when it has a mocked response', async () => {
-  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
+  const emitter = new Emitter<HttpRequestEventMap>()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', 'http://any.thing', {
       method: 'PUT',
@@ -88,7 +88,7 @@ it('gracefully finishes the request when it has a mocked response', async () =>
 })
 
 it('responds with a mocked response when requesting an existing hostname', async () => {
-  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
+  const emitter = new Emitter<HttpRequestEventMap>()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', httpServer.http.url('/comment')),
     {
@@ -116,7 +116,7 @@ it('responds with a mocked response when requesting an existing hostname', async
 })
 
 it('performs the request as-is given resolver returned no mocked response', async () => {
-  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
+  const emitter = new Emitter<HttpRequestEventMap>()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', httpServer.http.url('/comment'), {
       method: 'POST',
@@ -147,7 +147,7 @@ it('performs the request as-is given resolver returned no mocked response', asyn
 })
 
 it('emits the ENOTFOUND error connecting to a non-existing hostname given no mocked response', async () => {
-  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
+  const emitter = new Emitter<HttpRequestEventMap>()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', 'http://non-existing-url.com'),
     { emitter, logger }
@@ -165,7 +165,7 @@ it('emits the ENOTFOUND error connecting to a non-existing hostname given no moc
 })
 
 it('emits the ECONNREFUSED error connecting to an inactive server given no mocked response', async () => {
-  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
+  const emitter = new Emitter<HttpRequestEventMap>()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', 'http://127.0.0.1:12345'),
     {
@@ -191,7 +191,7 @@ it('emits the ECONNREFUSED error connecting to an inactive server given no mocke
 })
 
 it('does not emit ENOTFOUND error connecting to an inactive server given mocked response', async () => {
-  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
+  const emitter = new Emitter<HttpRequestEventMap>()
   const handleError = vi.fn()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', 'http://non-existing-url.com'),
@@ -221,7 +221,7 @@ it('does not emit ENOTFOUND error connecting to an inactive server given mocked
 })
 
 it('does not emit ECONNREFUSED error connecting to an inactive server given mocked response', async () => {
-  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
+  const emitter = new Emitter<HttpRequestEventMap>()
   const handleError = vi.fn()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', 'http://localhost:9876'),
@@ -253,7 +253,7 @@ it('does not emit ECONNREFUSED error connecting to an inactive server given mock
 })
 
 it('sends the request body to the server given no mocked response', async () => {
-  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
+  const emitter = new Emitter<HttpRequestEventMap>()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', httpServer.http.url('/write'), {
       method: 'POST',
@@ -284,7 +284,7 @@ it('sends the request body to the server given no mocked response', async () =>
 })
 
 it('does not send request body to the original server given mocked response', async () => {
-  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
+  const emitter = new Emitter<HttpRequestEventMap>()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', httpServer.http.url('/write'), {
       method: 'POST',