nock 13.5.4 → 14.0.0-beta.10

package/README.md

@@ -1,13 +1,11 @@
 # Nock
 
 [![npm](https://img.shields.io/npm/v/nock.svg)][npmjs]
-[![Build Status](https://travis-ci.org/nock/nock.svg)][build]
 ![Coverage Status](http://img.shields.io/badge/coverage-100%25-brightgreen.svg)
 [![Backers on Open Collective](https://opencollective.com/nock/backers/badge.svg)](#backers)
 [![Sponsors on Open Collective](https://opencollective.com/nock/sponsors/badge.svg)](#sponsors)
 
 [npmjs]: https://www.npmjs.com/package/nock
-[build]: https://travis-ci.org/nock/nock
 
 > **Notice**
 >
@@ -1643,10 +1641,10 @@ It does this by manipulating the modules cache of Node in a way that conflicts w
 
 ## Debugging
 
-Nock uses [`debug`](https://github.com/visionmedia/debug), so just run with environmental variable `DEBUG` set to `nock.*`.
+Nock uses node internals [`debuglog`](https://nodejs.org/api/util.html#utildebuglogsection-callbackg), so just run with environmental variable `NODE_DEBUG` set to `nock:*`.
 
 ```console
-user@local$ DEBUG=nock.* node my_test.js
+user@local$ NODE_DEBUG=nock:* node my_test.js
 ```
 
 Each step in the matching process is logged this way and can be useful when determining why a request was not intercepted by Nock.
@@ -1660,11 +1658,11 @@ await got('http://example.com/?foo=bar&baz=foz')
 ```
 
 ```console
-user@local$ DEBUG=nock.scope:example.com node my_test.js
+user@local$ DEBUG=nock:scope:example.com node my_test.js
 ...
-nock.scope:example.com Interceptor queries: {"foo":"bar"} +1ms
-nock.scope:example.com     Request queries: {"foo":"bar","baz":"foz"} +0ms
-nock.scope:example.com query matching failed +0ms
+NOCK:SCOPE:EXAMPLE.COM 103514: Interceptor queries: {"foo":"bar"}
+NOCK:SCOPE:EXAMPLE.COM 103514:     Request queries: {"foo":"bar","baz":"foz"}
+NOCK:SCOPE:EXAMPLE.COM 103514: query matching failed
 ```
 
 ## Contributing

package/lib/back.js

@@ -9,10 +9,9 @@ const {
   removeAll: cleanAll,
 } = require('./intercept')
 const { loadDefs, define } = require('./scope')
-
+const { back: debug } = require('./debug')
 const { format } = require('util')
 const path = require('path')
-const debug = require('debug')('nock.back')
 
 let _mode = null
 
@@ -78,7 +77,6 @@ function Back(fixtureName, options, nockedFn) {
   }
 
   debug('context:', context)
-
   // If nockedFn is a function then invoke it, otherwise return a promise resolving to nockDone.
   if (typeof nockedFn === 'function') {
     nockedFn.call(context, nockDone)

package/lib/common.js

@@ -1,9 +1,10 @@
 'use strict'
 
-const debug = require('debug')('nock.common')
+const { common: debug } = require('./debug')
 const timers = require('timers')
 const url = require('url')
 const util = require('util')
+const http = require('http')
 
 /**
  * Normalizes the request options so that it always has `host` property.
@@ -50,82 +51,6 @@ function isUtf8Representable(buffer) {
   return reconstructedBuffer.equals(buffer)
 }
 
-//  Array where all information about all the overridden requests are held.
-let requestOverrides = {}
-
-/**
- * Overrides the current `request` function of `http` and `https` modules with
- * our own version which intercepts issues HTTP/HTTPS requests and forwards them
- * to the given `newRequest` function.
- *
- * @param  {Function} newRequest - a function handling requests; it accepts four arguments:
- *   - proto - a string with the overridden module's protocol name (either `http` or `https`)
- *   - overriddenRequest - the overridden module's request function already bound to module's object
- *   - options - the options of the issued request
- *   - callback - the callback of the issued request
- */
-function overrideRequests(newRequest) {
-  debug('overriding requests')
-  ;['http', 'https'].forEach(function (proto) {
-    debug('- overriding request for', proto)
-
-    const moduleName = proto // 1 to 1 match of protocol and module is fortunate :)
-    const module = require(proto)
-    const overriddenRequest = module.request
-    const overriddenGet = module.get
-
-    if (requestOverrides[moduleName]) {
-      throw new Error(
-        `Module's request already overridden for ${moduleName} protocol.`,
-      )
-    }
-
-    //  Store the properties of the overridden request so that it can be restored later on.
-    requestOverrides[moduleName] = {
-      module,
-      request: overriddenRequest,
-      get: overriddenGet,
-    }
-    // https://nodejs.org/api/http.html#http_http_request_url_options_callback
-    module.request = function (input, options, callback) {
-      return newRequest(proto, overriddenRequest.bind(module), [
-        input,
-        options,
-        callback,
-      ])
-    }
-    // https://nodejs.org/api/http.html#http_http_get_options_callback
-    module.get = function (input, options, callback) {
-      const req = newRequest(proto, overriddenGet.bind(module), [
-        input,
-        options,
-        callback,
-      ])
-      req.end()
-      return req
-    }
-
-    debug('- overridden request for', proto)
-  })
-}
-
-/**
- * Restores `request` function of `http` and `https` modules to values they
- * held before they were overridden by us.
- */
-function restoreOverriddenRequests() {
-  debug('restoring requests')
-  Object.entries(requestOverrides).forEach(
-    ([proto, { module, request, get }]) => {
-      debug('- restoring request for', proto)
-      module.request = request
-      module.get = get
-      debug('- restored request for', proto)
-    },
-  )
-  requestOverrides = {}
-}
-
 /**
  * In WHATWG URL vernacular, this returns the origin portion of a URL.
  * However, the port is not included if it's standard and not already present on the host.
@@ -593,31 +518,36 @@ function deepEqual(expected, actual) {
   return expected === actual
 }
 
-const timeouts = []
-const intervals = []
-const immediates = []
+const timeouts = new Set()
+const immediates = new Set()
 
 const wrapTimer =
   (timer, ids) =>
-  (...args) => {
-    const id = timer(...args)
-    ids.push(id)
+  (callback, ...timerArgs) => {
+    const cb = (...callbackArgs) => {
+      try {
+        // eslint-disable-next-line n/no-callback-literal
+        callback(...callbackArgs)
+      } finally {
+        ids.delete(id)
+      }
+    }
+    const id = timer(cb, ...timerArgs)
+    ids.add(id)
     return id
   }
 
 const setTimeout = wrapTimer(timers.setTimeout, timeouts)
-const setInterval = wrapTimer(timers.setInterval, intervals)
 const setImmediate = wrapTimer(timers.setImmediate, immediates)
 
 function clearTimer(clear, ids) {
-  while (ids.length) {
-    clear(ids.shift())
-  }
+  ids.forEach(clear)
+  ids.clear()
 }
 
 function removeAllTimers() {
+  debug('remove all timers')
   clearTimer(clearTimeout, timeouts)
-  clearTimer(clearInterval, intervals)
   clearTimer(clearImmediate, immediates)
 }
 
@@ -649,6 +579,31 @@ function isRequestDestroyed(req) {
   )
 }
 
+/**
+ * @param {Request} request
+ */
+function convertFetchRequestToClientRequest(request) {
+  const url = new URL(request.url)
+  const options = {
+    ...urlToOptions(url),
+    method: request.method,
+    host: url.hostname,
+    port: url.port || (url.protocol === 'https:' ? 443 : 80),
+    path: url.pathname + url.search,
+    proto: url.protocol.slice(0, -1),
+    headers: Object.fromEntries(request.headers.entries()),
+  }
+
+  // By default, Node adds a host header, but for maximum backward compatibility, we are now removing it.
+  // However, we need to consider leaving the header and fixing the tests.
+  if (options.headers.host === options.host) {
+    const { host, ...restHeaders } = options.headers
+    options.headers = restHeaders
+  }
+
+  return new http.ClientRequest(options)
+}
+
 /**
  * Returns true if the given value is a plain object and not an Array.
  * @param {*} value
@@ -756,13 +711,11 @@ module.exports = {
   normalizeClientRequestArgs,
   normalizeOrigin,
   normalizeRequestOptions,
-  overrideRequests,
   percentDecode,
   percentEncode,
   removeAllTimers,
-  restoreOverriddenRequests,
   setImmediate,
-  setInterval,
   setTimeout,
   stringifyRequest,
+  convertFetchRequestToClientRequest,
 }

package/lib/create_response.js

@@ -0,0 +1,51 @@
+'use strict'
+
+const { STATUS_CODES } = require('http')
+
+/**
+ * Creates a Fetch API `Response` instance from the given
+ * `http.IncomingMessage` instance.
+ * Inspired by: https://github.com/mswjs/interceptors/blob/04152ed914f8041272b6e92ed374216b8177e1b2/src/interceptors/ClientRequest/utils/createResponse.ts#L8
+ */
+
+/**
+ * Response status codes for responses that cannot have body.
+ * @see https://fetch.spec.whatwg.org/#statuses
+ */
+const responseStatusCodesWithoutBody = [204, 205, 304]
+
+/**
+ * @param {import('http').IncomingMessage} message
+ */
+function createResponse(message) {
+  const responseBodyOrNull = responseStatusCodesWithoutBody.includes(
+    message.statusCode || 200,
+  )
+    ? null
+    : new ReadableStream({
+        start(controller) {
+          message.on('data', chunk => controller.enqueue(chunk))
+          message.on('end', () => controller.close())
+          message.on('error', error => controller.error(error))
+        },
+        cancel() {
+          message.destroy()
+        },
+      })
+
+  const rawHeaders = new Headers()
+  for (let i = 0; i < message.rawHeaders.length; i += 2) {
+    rawHeaders.append(message.rawHeaders[i], message.rawHeaders[i + 1])
+  }
+
+  // @mswjs/interceptors supports rawHeaders. https://github.com/mswjs/interceptors/pull/598
+  const response = new Response(responseBodyOrNull, {
+    status: message.statusCode,
+    statusText: message.statusMessage || STATUS_CODES[message.statusCode],
+    headers: rawHeaders,
+  })
+
+  return response
+}
+
+module.exports = { createResponse }

package/lib/debug.js

@@ -0,0 +1,12 @@
+'use strict'
+
+const { debuglog } = require('util')
+
+module.exports.back = debuglog('nock:back')
+module.exports.common = debuglog('nock:common')
+module.exports.intercept = debuglog('nock:intercept')
+module.exports.request_overrider = debuglog('nock:request_overrider')
+module.exports.playback_interceptor = debuglog('nock:playback_interceptor')
+module.exports.recorder = debuglog('nock:recorder')
+module.exports.socket = debuglog('nock:socket')
+module.exports.scopeDebuglog = namespace => debuglog(`nock:scope:${namespace}`)

package/lib/intercept.js

@@ -8,8 +8,20 @@ const { InterceptedRequestRouter } = require('./intercepted_request_router')
 const common = require('./common')
 const { inherits } = require('util')
 const http = require('http')
-const debug = require('debug')('nock.intercept')
+const { intercept: debug } = require('./debug')
 const globalEmitter = require('./global_emitter')
+const { BatchInterceptor } = require('@mswjs/interceptors')
+const {
+  default: nodeInterceptors,
+} = require('@mswjs/interceptors/presets/node')
+const { createResponse } = require('./create_response')
+const { once } = require('events')
+
+const interceptor = new BatchInterceptor({
+  name: 'nock-interceptor',
+  interceptors: nodeInterceptors,
+})
+let isNockActive = false
 
 /**
  * @name NetConnectNotAllowedError
@@ -238,17 +250,6 @@ function removeInterceptor(options) {
 //  (which might or might not be node's original http.ClientRequest)
 let originalClientRequest
 
-function ErroringClientRequest(error) {
-  http.OutgoingMessage.call(this)
-  process.nextTick(
-    function () {
-      this.emit('error', error)
-    }.bind(this),
-  )
-}
-
-inherits(ErroringClientRequest, http.ClientRequest)
-
 function overrideClientRequest() {
   // Here's some background discussion about overriding ClientRequest:
   // - https://github.com/nodejitsu/mock-request/issues/4
@@ -333,6 +334,8 @@ function restoreOverriddenClientRequest() {
   if (!originalClientRequest) {
     debug('- ClientRequest was not overridden')
   } else {
+    isNockActive = false
+    interceptor.dispose()
     http.ClientRequest = originalClientRequest
     originalClientRequest = undefined
 
@@ -341,9 +344,7 @@ function restoreOverriddenClientRequest() {
 }
 
 function isActive() {
-  //  If ClientRequest has been overwritten by Nock then originalClientRequest is not undefined.
-  //  This means that Nock has been activated.
-  return originalClientRequest !== undefined
+  return isNockActive
 }
 
 function interceptorScopes() {
@@ -367,75 +368,61 @@ function activeMocks() {
 }
 
 function activate() {
-  if (originalClientRequest) {
+  if (isNockActive) {
     throw new Error('Nock already active')
   }
 
-  // ----- Overriding http.request and https.request:
-
-  common.overrideRequests(function (proto, overriddenRequest, args) {
-    //  NOTE: overriddenRequest is already bound to its module.
-
-    const { options, callback } = common.normalizeClientRequestArgs(...args)
-
-    if (Object.keys(options).length === 0) {
-      // As weird as it is, it's possible to call `http.request` without
-      // options, and it makes a request to localhost or somesuch. We should
-      // support it too, for parity. However it doesn't work today, and fixing
-      // it seems low priority. Giving an explicit error is nicer than
-      // crashing with a weird stack trace. `new ClientRequest()`, nock's
-      // other client-facing entry point, makes a similar check.
-      // https://github.com/nock/nock/pull/1386
-      // https://github.com/nock/nock/pull/1440
-      throw Error(
-        'Making a request with empty `options` is not supported in Nock',
-      )
-    }
-
-    // The option per the docs is `protocol`. Its unclear if this line is meant to override that and is misspelled or if
-    // the intend is to explicitly keep track of which module was called using a separate name.
-    // Either way, `proto` is used as the source of truth from here on out.
-    options.proto = proto
-
-    const interceptors = interceptorsFor(options)
-
-    if (isOn() && interceptors) {
-      const matches = interceptors.some(interceptor =>
-        interceptor.matchOrigin(options),
-      )
-      const allowUnmocked = interceptors.some(
-        interceptor => interceptor.options.allowUnmocked,
-      )
+  overrideClientRequest()
+  interceptor.apply()
+  // Force msw to forward Nock's error instead of coerce it into 500 error
+  interceptor.on('unhandledException', ({ controller, error }) => {
+    controller.errorWith(error)
+  })
+  interceptor.on(
+    'request',
+    async function ({ request: mswRequest, controller }) {
+      const request = mswRequest.clone()
+      const { options } = common.normalizeClientRequestArgs(request.url)
+      options.proto = options.protocol.slice(0, -1)
+      options.method = request.method
+      const interceptors = interceptorsFor(options)
+      if (isOn() && interceptors) {
+        const matches = interceptors.some(interceptor =>
+          interceptor.matchOrigin(options),
+        )
+        const allowUnmocked = interceptors.some(
+          interceptor => interceptor.options.allowUnmocked,
+        )
 
-      if (!matches && allowUnmocked) {
-        let req
-        if (proto === 'https') {
-          const { ClientRequest } = http
-          http.ClientRequest = originalClientRequest
-          req = overriddenRequest(options, callback)
-          http.ClientRequest = ClientRequest
+        const nockRequest = common.convertFetchRequestToClientRequest(request)
+        if (!matches && allowUnmocked) {
+          globalEmitter.emit('no match', nockRequest)
         } else {
-          req = overriddenRequest(options, callback)
+          nockRequest.on('response', nockResponse => {
+            const response = createResponse(nockResponse)
+            controller.respondWith(response)
+          })
+
+          const promise = Promise.race([
+            // TODO: temp hacky way to handle allowUnmocked in startPlayback
+            once(nockRequest, 'real-request'),
+            once(nockRequest, 'error'),
+            once(nockRequest, 'response'),
+          ])
+          const buffer = await request.arrayBuffer()
+          nockRequest.write(buffer)
+          nockRequest.end()
+          await promise
         }
-        globalEmitter.emit('no match', req)
-        return req
-      }
-
-      //  NOTE: Since we already overrode the http.ClientRequest we are in fact constructing
-      //    our own OverriddenClientRequest.
-      return new http.ClientRequest(options, callback)
-    } else {
-      globalEmitter.emit('no match', options)
-      if (isOff() || isEnabledForNetConnect(options)) {
-        return overriddenRequest(options, callback)
       } else {
-        const error = new NetConnectNotAllowedError(options.host, options.path)
-        return new ErroringClientRequest(error)
+        globalEmitter.emit('no match', options)
+        if (!(isOff() || isEnabledForNetConnect(options))) {
+          throw new NetConnectNotAllowedError(options.host, options.path)
+        }
       }
-    }
-  })
-
-  overrideClientRequest()
+    },
+  )
+  isNockActive = true
 }
 
 module.exports = {

package/lib/intercepted_request_router.js

@@ -1,12 +1,7 @@
 'use strict'
 
-const debug = require('debug')('nock.request_overrider')
-const {
-  IncomingMessage,
-  ClientRequest,
-  request: originalHttpRequest,
-} = require('http')
-const { request: originalHttpsRequest } = require('https')
+const { request_overrider: debug } = require('./debug')
+const { IncomingMessage, ClientRequest } = require('http')
 const propagate = require('propagate')
 const common = require('./common')
 const globalEmitter = require('./global_emitter')
@@ -333,14 +328,7 @@ class InterceptedRequestRouter {
       )
 
       if (allowUnmocked && req instanceof ClientRequest) {
-        const newReq =
-          options.proto === 'https'
-            ? originalHttpsRequest(options)
-            : originalHttpRequest(options)
-
-        propagate(newReq, req)
-        // We send the raw buffer as we received it, not as we interpreted it.
-        newReq.end(requestBodyBuffer)
+        req.emit('real-request')
       } else {
         const reqStr = common.stringifyRequest(options, requestBodyString)
         const err = new Error(`Nock: No match for request ${reqStr}`)

package/lib/interceptor.js

@@ -248,14 +248,7 @@ module.exports = class Interceptor {
   }
 
   match(req, options, body) {
-    // check if the logger is enabled because the stringifies can be expensive.
-    if (this.scope.logger.enabled) {
-      this.scope.logger(
-        'attempting match %s, body = %s',
-        stringify(options),
-        stringify(body),
-      )
-    }
+    this.scope.logger('attempting match %j, body = %j', options, body)
 
     const method = (options.method || 'GET').toUpperCase()
     let { path = '/' } = options

package/lib/match_body.js

@@ -63,10 +63,11 @@ module.exports = function matchBody(options, spec, body) {
 
 function mapValues(object, cb) {
   const keys = Object.keys(object)
+  const clonedObject = { ...object }
   for (const key of keys) {
-    object[key] = cb(object[key], key, object)
+    clonedObject[key] = cb(clonedObject[key], key, clonedObject)
   }
-  return object
+  return clonedObject
 }
 
 /**

package/lib/playback_interceptor.js

@@ -3,7 +3,7 @@
 const stream = require('stream')
 const util = require('util')
 const zlib = require('zlib')
-const debug = require('debug')('nock.playback_interceptor')
+const { playback_interceptor: debug } = require('./debug')
 const common = require('./common')
 
 function parseJSONRequestBody(req, requestBody) {

package/lib/recorder.js

@@ -1,16 +1,27 @@
 'use strict'
 
-const debug = require('debug')('nock.recorder')
+const { recorder: debug } = require('./debug')
 const querystring = require('querystring')
 const { inspect } = require('util')
 
 const common = require('./common')
 const { restoreOverriddenClientRequest } = require('./intercept')
+const { BatchInterceptor } = require('@mswjs/interceptors')
+const {
+  default: nodeInterceptors,
+} = require('@mswjs/interceptors/presets/node')
+const { EventEmitter } = require('stream')
 
 const SEPARATOR = '\n<<<<<<-- cut here -->>>>>>\n'
 let recordingInProgress = false
 let outputs = []
 
+// TODO: Consider use one BatchInterceptor (and not one for intercept and one for record)
+const interceptor = new BatchInterceptor({
+  name: 'nock-interceptor',
+  interceptors: nodeInterceptors,
+})
+
 function getScope(options) {
   const { proto, host, port } = common.normalizeRequestOptions(options)
   return common.normalizeOrigin(proto, host, port)
@@ -210,158 +221,114 @@ function record(recOptions) {
   //  we restore any requests that may have been overridden by other parts of nock (e.g. intercept)
   //  NOTE: This is hacky as hell but it keeps the backward compatibility *and* allows correct
   //    behavior in the face of other modules also overriding ClientRequest.
-  common.restoreOverriddenRequests()
+  // common.restoreOverriddenRequests()
   //  We restore ClientRequest as it messes with recording of modules that also override ClientRequest (e.g. xhr2)
   restoreOverriddenClientRequest()
 
   //  We override the requests so that we can save information on them before executing.
-  common.overrideRequests(function (proto, overriddenRequest, rawArgs) {
-    const { options, callback } = common.normalizeClientRequestArgs(...rawArgs)
-    const bodyChunks = []
-
-    // Node 0.11 https.request calls http.request -- don't want to record things
-    // twice.
-    /* istanbul ignore if */
-    if (options._recording) {
-      return overriddenRequest(options, callback)
-    }
-    options._recording = true
-
-    const req = overriddenRequest(options, function (res) {
-      debug(thisRecordingId, 'intercepting', proto, 'request to record')
-
-      //  We put our 'end' listener to the front of the listener array.
-      res.once('end', function () {
-        debug(thisRecordingId, proto, 'intercepted request ended')
-
-        let reqheaders
-        // Ignore request headers completely unless it was explicitly enabled by the user (see README)
-        if (enableReqHeadersRecording) {
-          // We never record user-agent headers as they are worse than useless -
-          // they actually make testing more difficult without providing any benefit (see README)
-          reqheaders = req.getHeaders()
-          common.deleteHeadersField(reqheaders, 'user-agent')
-        }
+  interceptor.apply()
+  interceptor.on(
+    'request',
+    async function ({ request: mswRequest, requestId }) {
+      const request = mswRequest.clone()
+      const { options } = common.normalizeClientRequestArgs(request.url)
+      options.method = request.method
+      const proto = options.protocol.slice(0, -1)
+
+      // Node 0.11 https.request calls http.request -- don't want to record things
+      // twice.
+      /* istanbul ignore if */
+      if (options._recording) {
+        return
+      }
+      options._recording = true
+
+      const req = new EventEmitter()
+      req.on('response', function () {
+        debug(thisRecordingId, 'intercepting', proto, 'request to record')
+
+        // Intercept "res.once('end', ...)"-like event
+        interceptor.once(
+          'response',
+          async function ({ response: mswResponse }) {
+            const response = mswResponse.clone()
+            debug(thisRecordingId, proto, 'intercepted request ended')
+
+            let reqheaders
+            // Ignore request headers completely unless it was explicitly enabled by the user (see README)
+            if (enableReqHeadersRecording) {
+              // We never record user-agent headers as they are worse than useless -
+              // they actually make testing more difficult without providing any benefit (see README)
+              reqheaders = Object.fromEntries(request.headers.entries())
+              common.deleteHeadersField(reqheaders, 'user-agent')
+            }
 
-        const generateFn = outputObjects
-          ? generateRequestAndResponseObject
-          : generateRequestAndResponse
-        let out = generateFn({
-          req,
-          bodyChunks,
-          options,
-          res,
-          dataChunks,
-          reqheaders,
-        })
-
-        debug('out:', out)
-
-        //  Check that the request was made during the current recording.
-        //  If it hasn't then skip it. There is no other simple way to handle
-        //  this as it depends on the timing of requests and responses. Throwing
-        //  will make some recordings/unit tests fail randomly depending on how
-        //  fast/slow the response arrived.
-        //  If you are seeing this error then you need to make sure that all
-        //  the requests made during a single recording session finish before
-        //  ending the same recording session.
-        if (thisRecordingId !== currentRecordingId) {
-          debug('skipping recording of an out-of-order request', out)
-          return
-        }
+            const headers = Object.fromEntries(response.headers.entries())
+            const res = {
+              statusCode: response.status,
+              headers,
+              rawHeaders: headers,
+            }
 
-        outputs.push(out)
+            const generateFn = outputObjects
+              ? generateRequestAndResponseObject
+              : generateRequestAndResponse
+            let out = generateFn({
+              req: options,
+              bodyChunks: [Buffer.from(await request.arrayBuffer())],
+              options,
+              res,
+              dataChunks: [Buffer.from(await response.arrayBuffer())],
+              reqheaders,
+            })
+
+            debug('out:', out)
+
+            //  Check that the request was made during the current recording.
+            //  If it hasn't then skip it. There is no other simple way to handle
+            //  this as it depends on the timing of requests and responses. Throwing
+            //  will make some recordings/unit tests fail randomly depending on how
+            //  fast/slow the response arrived.
+            //  If you are seeing this error then you need to make sure that all
+            //  the requests made during a single recording session finish before
+            //  ending the same recording session.
+            if (thisRecordingId !== currentRecordingId) {
+              debug('skipping recording of an out-of-order request', out)
+              return
+            }
 
-        if (!dontPrint) {
-          if (useSeparator) {
-            if (typeof out !== 'string') {
-              out = JSON.stringify(out, null, 2)
+            outputs.push(out)
+
+            if (!dontPrint) {
+              if (useSeparator) {
+                if (typeof out !== 'string') {
+                  out = JSON.stringify(out, null, 2)
+                }
+                logging(SEPARATOR + out + SEPARATOR)
+              } else {
+                logging(out)
+              }
             }
-            logging(SEPARATOR + out + SEPARATOR)
-          } else {
-            logging(out)
-          }
-        }
-      })
+          },
+        )
 
-      let encoding
-      // We need to be aware of changes to the stream's encoding so that we
-      // don't accidentally mangle the data.
-      const { setEncoding } = res
-      res.setEncoding = function (newEncoding) {
-        encoding = newEncoding
-        return setEncoding.apply(this, arguments)
-      }
+        debug('finished setting up intercepting')
 
-      const dataChunks = []
-      // Replace res.push with our own implementation that stores chunks
-      const origResPush = res.push
-      res.push = function (data) {
-        if (data) {
-          if (encoding) {
-            data = Buffer.from(data, encoding)
-          }
-          dataChunks.push(data)
+        // We override both the http and the https modules; when we are
+        // serializing the request, we need to know which was called.
+        // By stuffing the state, we can make sure that nock records
+        // the intended protocol.
+        if (proto === 'https') {
+          options.proto = 'https'
         }
+      })
 
-        return origResPush.call(res, data)
-      }
-
-      if (callback) {
-        callback(res, options, callback)
-      }
-
-      debug('finished setting up intercepting')
-
-      // We override both the http and the https modules; when we are
-      // serializing the request, we need to know which was called.
-      // By stuffing the state, we can make sure that nock records
-      // the intended protocol.
-      if (proto === 'https') {
-        options.proto = 'https'
-      }
-    })
-
-    const recordChunk = (chunk, encoding) => {
-      debug(thisRecordingId, 'new', proto, 'body chunk')
-      if (!Buffer.isBuffer(chunk)) {
-        chunk = Buffer.from(chunk, encoding)
-      }
-      bodyChunks.push(chunk)
-    }
-
-    const oldWrite = req.write
-    req.write = function (chunk, encoding) {
-      if (typeof chunk !== 'undefined') {
-        recordChunk(chunk, encoding)
-        oldWrite.apply(req, arguments)
-      } else {
-        throw new Error('Data was undefined.')
-      }
-    }
-
-    // Starting in Node 8, `OutgoingMessage.end()` directly calls an internal
-    // `write_` function instead of proxying to the public
-    // `OutgoingMessage.write()` method, so we have to wrap `end` too.
-    const oldEnd = req.end
-    req.end = function (chunk, encoding, callback) {
-      debug('req.end')
-      if (typeof chunk === 'function') {
-        callback = chunk
-        chunk = null
-      } else if (typeof encoding === 'function') {
-        callback = encoding
-        encoding = null
-      }
-
-      if (chunk) {
-        recordChunk(chunk, encoding)
-      }
-      oldEnd.call(req, chunk, encoding, callback)
-    }
-
-    return req
-  })
+      // This is a massive change, we are trying to change minimum code, so we emit end event here
+      // because mswjs take care for these events
+      // TODO: refactor the recorder, we no longer need all the listeners and can just record the request we get from MSW
+      req.emit('response')
+    },
+  )
 }
 
 // Restore *all* the overridden http/https modules' properties.
@@ -371,7 +338,7 @@ function restore() {
     'restoring all the overridden http/https properties',
   )
 
-  common.restoreOverriddenRequests()
+  interceptor.dispose()
   restoreOverriddenClientRequest()
   recordingInProgress = false
 }

package/lib/scope.js

@@ -3,11 +3,11 @@
 /**
  * @module nock/scope
  */
+const { scopeDebuglog } = require('./debug')
 const { addInterceptor, isOn } = require('./intercept')
 const common = require('./common')
 const assert = require('assert')
 const url = require('url')
-const debug = require('debug')('nock.scope')
 const { EventEmitter } = require('events')
 const Interceptor = require('./interceptor')
 
@@ -99,7 +99,7 @@ class Scope extends EventEmitter {
       logNamespace = this.urlParts.host
     }
 
-    this.logger = debug.extend(logNamespace)
+    this.logger = scopeDebuglog(logNamespace)
   }
 
   add(key, interceptor) {

package/lib/socket.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { EventEmitter } = require('events')
-const debug = require('debug')('nock.socket')
+const { socket: debug } = require('./debug')
 
 module.exports = class Socket extends EventEmitter {
   constructor(options) {

package/package.json

@@ -7,7 +7,7 @@
     "testing",
     "isolation"
   ],
-  "version": "13.5.4",
+  "version": "14.0.0-beta.10",
   "author": "Pedro Teixeira <pedro.teixeira@gmail.com>",
   "repository": {
     "type": "git",
@@ -17,12 +17,12 @@
     "url": "https://github.com/nock/nock/issues"
   },
   "engines": {
-    "node": ">= 10.13"
+    "node": ">= 18"
   },
   "main": "./index.js",
   "types": "types",
   "dependencies": {
-    "debug": "^4.1.0",
+    "@mswjs/interceptors": "^0.34.0",
     "json-stringify-safe": "^5.0.1",
     "propagate": "^2.0.0"
   },
@@ -45,11 +45,11 @@
     "mocha": "^9.1.3",
     "npm-run-all": "^4.1.5",
     "nyc": "^15.0.0",
-    "prettier": "3.2.4",
+    "prettier": "3.2.5",
     "proxyquire": "^2.1.0",
     "rimraf": "^3.0.0",
     "semantic-release": "^22.0.5",
-    "sinon": "^15.0.1",
+    "sinon": "^17.0.1",
     "sinon-chai": "^3.7.0",
     "typescript": "^5.0.4"
   },

package/types/index.d.ts

@@ -256,13 +256,13 @@ declare namespace nock {
     (
       fixtureName: string,
       options: BackOptions,
-      nockedFn: (nockDone: () => void) => void,
+      nockedFn: (nockDone: () => Promise<void>) => void,
     ): void
     (
       fixtureName: string,
       options?: BackOptions,
     ): Promise<{
-      nockDone: () => void
+      nockDone: () => Promise<void>
       context: BackContext
     }>
   }