nock 15.0.0 → 15.0.1

package/{lib → dist/lib}/match_body.js

@@ -1,16 +1,7 @@
-'use strict'
+import querystring from 'node:querystring'
+import * as common from './common.js'
 
-const querystring = require('node:querystring')
-
-const common = require('./common')
-
-/**
- * @param {Request} request
- * @param {*} spec
- * @param {string} body - string or hex
- * @returns
- */
-module.exports = function matchBody(request, spec, body) {
+export default function matchBody(request         , spec     , body        ) {
   if (spec instanceof RegExp) {
     return spec.test(body)
   }
@@ -26,6 +17,7 @@ module.exports = function matchBody(request, spec, body) {
 
   // try to transform body to json or query string
   let json
+  let matchBody                               = body
   if (typeof spec === 'object' || typeof spec === 'function') {
     try {
       json = JSON.parse(body)
@@ -33,20 +25,20 @@ module.exports = function matchBody(request, spec, body) {
       // not a valid JSON string
     }
     if (json !== undefined) {
-      body = json
+      matchBody = json
     } else if (isUrlencoded) {
-      body = querystring.parse(body)
+      matchBody = querystring.parse(body)
     }
   }
 
   if (typeof spec === 'function') {
-    return spec(body)
+    return spec(matchBody)
   }
 
   // strip line endings from both so that we get a match no matter what OS we are running on
   // if Content-Type does not contain 'multipart'
-  if (!isMultipart && typeof body === 'string') {
-    body = body.replace(/\r?\n|\r/g, '')
+  if (!isMultipart && typeof matchBody === 'string') {
+    matchBody = matchBody.replace(/\r?\n|\r/g, '')
   }
 
   if (!isMultipart && typeof spec === 'string') {
@@ -56,13 +48,18 @@ module.exports = function matchBody(request, spec, body) {
   // Because the nature of URL encoding, all the values in the body must be cast to strings.
   // dataEqual does strict checking, so we have to cast the non-regexp values in the spec too.
   if (isUrlencoded) {
-    spec = mapValuesDeep(spec, val => (val instanceof RegExp ? val : `${val}`))
+    spec = mapValuesDeep(spec, (val     ) =>
+      val instanceof RegExp ? val : `${val}`,
+    )
   }
 
-  return common.dataEqual(spec, body)
+  return common.dataEqual(spec, matchBody)
 }
 
-function mapValues(object, cb) {
+function mapValues(
+  object                     ,
+  cb                                                               ,
+) {
   const keys = Object.keys(object)
   const clonedObject = { ...object }
   for (const key of keys) {
@@ -71,16 +68,12 @@ function mapValues(object, cb) {
   return clonedObject
 }
 
-/**
- * Based on lodash issue discussion
- * https://github.com/lodash/lodash/issues/1244
- */
-function mapValuesDeep(obj, cb) {
+function mapValuesDeep(obj     , cb                     )      {
   if (Array.isArray(obj)) {
-    return obj.map(v => mapValuesDeep(v, cb))
+    return obj.map((v     ) => mapValuesDeep(v, cb))
   }
   if (common.isPlainObject(obj)) {
-    return mapValues(obj, v => mapValuesDeep(v, cb))
+    return mapValues(obj, (v     ) => mapValuesDeep(v, cb))
   }
   return cb(obj)
 }

package/dist/lib/playback_interceptor.d.ts

@@ -0,0 +1,8 @@
+import type { Interceptor } from './interceptor.ts';
+declare function playbackInterceptor({ decompressedRequest, interceptor, requestBodyString, requestBodyIsUtf8Representable, }: {
+    decompressedRequest: Request;
+    requestBodyString: string;
+    requestBodyIsUtf8Representable: boolean;
+    interceptor: Interceptor;
+}): Promise<import("undici-types").Response>;
+export { playbackInterceptor };

package/{lib → dist/lib}/playback_interceptor.js

@@ -1,13 +1,12 @@
-'use strict'
-
-const { STATUS_CODES } = require('node:http')
-const stream = require('node:stream')
-const util = require('node:util')
-const { playback_interceptor: debug } = require('./debug')
-const common = require('./common')
-const { FetchResponse } = require('@mswjs/interceptors')
-
-function parseFullReplyResult(fullReplyResult) {
+                                                   
+import { STATUS_CODES } from 'node:http'
+import stream from 'node:stream'
+import util from 'node:util'
+import { playback_interceptor as debug } from './debug.js'
+import * as common from './common.js'
+import { FetchResponse } from '@mswjs/interceptors'
+
+function parseFullReplyResult(fullReplyResult       ) {
   debug('full response from callback result: %j', fullReplyResult)
 
   if (!Array.isArray(fullReplyResult)) {
@@ -32,23 +31,18 @@ function parseFullReplyResult(fullReplyResult) {
   return [status, body, rawHeaders]
 }
 
-/**
- * Determine which of the default headers should be added to the response.
- *
- * Don't include any defaults whose case-insensitive keys are already on the response.
- */
-function selectDefaultHeaders(existingHeaders, defaultHeaders) {
+function selectDefaultHeaders(existingHeaders       , defaultHeaders       ) {
   if (!defaultHeaders.length) {
     return [] // return early if we don't need to bother
   }
 
   const definedHeaders = new Set()
-  const result = []
+  const result                  = []
 
-  common.forEachHeader(existingHeaders, (_, fieldName) => {
+  common.forEachHeader(existingHeaders, (_     , fieldName        ) => {
     definedHeaders.add(fieldName.toLowerCase())
   })
-  common.forEachHeader(defaultHeaders, (value, fieldName) => {
+  common.forEachHeader(defaultHeaders, (value     , fieldName        ) => {
     if (!definedHeaders.has(fieldName.toLowerCase())) {
       result.push([fieldName, value])
     }
@@ -59,7 +53,9 @@ function selectDefaultHeaders(existingHeaders, defaultHeaders) {
 
 // Presents a list of Buffers as a Readable
 class ReadableBuffers extends stream.Readable {
-  constructor(buffers) {
+                           
+
+  constructor(buffers          ) {
     super()
 
     this.buffers = buffers
@@ -75,7 +71,7 @@ class ReadableBuffers extends stream.Readable {
   }
 }
 
-function convertBodyToStream(body) {
+function convertBodyToStream(body     ) {
   if (common.isStream(body)) {
     return body
   }
@@ -95,21 +91,17 @@ function convertBodyToStream(body) {
   return new ReadableBuffers([Buffer.from(body)])
 }
 
-/**
- * Play back an interceptor using the given request and mock response.
- *
- * @param {Object} param0
- * @param {Request} param0.decompressedRequest
- * @param {string} param0.requestBodyString
- * @param {boolean} param0.requestBodyIsUtf8Representable
- * @param {import('./interceptor').Interceptor} param0.interceptor
- */
 async function playbackInterceptor({
   decompressedRequest,
   interceptor,
   requestBodyString,
   requestBodyIsUtf8Representable,
-}) {
+}   
+                              
+                           
+                                         
+                          
+ ) {
   const { logger } = interceptor.scope
   interceptor.scope.emit(
     'request',
@@ -139,14 +131,14 @@ async function playbackInterceptor({
     let fn = interceptor.replyFunction
     if (fn.length === 2) {
       // Handle the case of an async reply function, the third parameter being the callback.
-      fn = util.promisify(fn)
+      fn = util.promisify(fn)       
     }
 
     // At this point `fn` is either a synchronous function or a promise-returning function;
     // wrapping in `Promise.resolve` makes it into a promise either way.
-    return Promise.resolve(fn.call(interceptor, decompressedRequest))
+    return Promise.resolve((fn       ).call(interceptor, decompressedRequest))
       .then(continueWithResponseBody)
-      .catch(err => {
+      .catch((err     ) => {
         throw err
       })
   }
@@ -154,35 +146,35 @@ async function playbackInterceptor({
   else if (interceptor.fullReplyFunction) {
     let fn = interceptor.fullReplyFunction
     if (fn.length === 2) {
-      fn = util.promisify(fn)
+      fn = util.promisify(fn)       
     }
 
-    return Promise.resolve(fn.call(interceptor, decompressedRequest))
+    return Promise.resolve((fn       ).call(interceptor, decompressedRequest))
       .then(continueWithFullResponse)
-      .catch(err => {
+      .catch((err     ) => {
         throw err
       })
   }
 
   if (
-    common.isContentEncoded(interceptor.headers) &&
+    common.isContentEncoded(interceptor.headers || {}) &&
     !common.isStream(interceptor.body)
   ) {
     //  If the content is encoded we know that the response body *must* be an array
     //  of response buffers which should be mocked one by one.
-    //  (otherwise decompressions after the first one fails as unzip expects to receive
-    //  buffer by buffer and not one single merged buffer)
     const bufferData = Array.isArray(interceptor.body)
       ? interceptor.body
       : [interceptor.body]
-    const responseBuffers = bufferData.map(data => Buffer.from(data, 'hex'))
+    const responseBuffers = bufferData.map((data        ) =>
+      Buffer.from(data, 'hex'),
+    )
     const responseBody = new ReadableBuffers(responseBuffers)
     return continueWithResponseBody(responseBody)
   }
 
   // If we get to this point, the body is either a string or an object that
   // will eventually be JSON stringified.
-  let responseBody = interceptor.body
+  let responseBody      = interceptor.body
 
   // If the request was not UTF8-representable then we assume that the
   // response won't be either. In that case we send the response as a Buffer
@@ -194,28 +186,26 @@ async function playbackInterceptor({
     // Creating buffers does not necessarily throw errors; check for difference in size.
     if (
       !responseBody ||
-      (interceptor.body.length > 0 && responseBody.length === 0)
+      ((interceptor.body          ).length > 0 && responseBody.length === 0)
     ) {
       // We fallback on constructing buffer from utf8 representation of the body.
-      responseBody = Buffer.from(interceptor.body, 'utf8')
+      responseBody = Buffer.from(interceptor.body          , 'utf8')
     }
   }
 
   return continueWithResponseBody(responseBody)
 
-  function continueWithFullResponse(fullReplyResult) {
+  function continueWithFullResponse(fullReplyResult                      ) {
     const [status, responseBody, rawHeaders] =
       parseFullReplyResult(fullReplyResult)
     return continueWithResponseBody(responseBody, status, rawHeaders)
   }
 
-  async function prepareResponseHeaders(body, responseHeaders) {
+  async function prepareResponseHeaders(body     , responseHeaders       ) {
     const defaultHeaders = [...interceptor.scope._defaultReplyHeaders]
-    const rawHeaders = []
+    const rawHeaders                  = []
 
     // Include a JSON content type when JSON.stringify is called on the body.
-    // This is a convenience added by Nock that has no analog in Node. It's added to the
-    // defaults, so it will be ignored if the caller explicitly provided the header already.
     const isJSON =
       body !== undefined &&
       typeof body !== 'string' &&
@@ -226,15 +216,15 @@ async function playbackInterceptor({
       defaultHeaders.push('Content-Type', 'application/json')
     }
     common.forEachHeader(
-      [...interceptor.rawHeaders, ...responseHeaders],
-      (value, fieldName) => {
+      [...(interceptor.rawHeaders || []), ...responseHeaders],
+      (value     , fieldName        ) => {
         rawHeaders.push([fieldName, value])
       },
     )
 
     rawHeaders.push(
       ...selectDefaultHeaders(
-        [...interceptor.rawHeaders, ...responseHeaders],
+        [...(interceptor.rawHeaders || []), ...responseHeaders],
         defaultHeaders,
       ),
     )
@@ -244,7 +234,7 @@ async function playbackInterceptor({
 
       // Evaluate functional headers.
       if (typeof value === 'function') {
-        rawHeaders[i][1] = await value(decompressedRequest)
+        rawHeaders[i][1] = await value(decompressedRequest, body)
       }
     }
 
@@ -252,9 +242,9 @@ async function playbackInterceptor({
   }
 
   async function continueWithResponseBody(
-    rawBody,
-    fullResponseStatus,
-    fullResponseRawHeaders = [],
+    rawBody     ,
+    fullResponseStatus         ,
+    fullResponseRawHeaders        = [],
   ) {
     const headers = await prepareResponseHeaders(
       rawBody,
@@ -268,7 +258,7 @@ async function playbackInterceptor({
     const readable = new stream.Readable({
       read() {},
     })
-    bodyAsStream.on('data', function (chunk) {
+    bodyAsStream.on('data', function (chunk        ) {
       readable.push(chunk)
     })
     bodyAsStream.on('end', function () {
@@ -277,18 +267,18 @@ async function playbackInterceptor({
         interceptor.scope.emit('replied', decompressedRequest, interceptor)
       }, interceptor.delayBodyInMs)
     })
-    bodyAsStream.on('error', function (err) {
+    bodyAsStream.on('error', function (err       ) {
       readable.emit('error', err)
     })
 
     const status = interceptor.statusCode || fullResponseStatus
-    const hasBody = FetchResponse.isResponseWithBody(status)
+    const hasBody = FetchResponse.isResponseWithBody(status          )
     return new Response(hasBody ? readable : null, {
-      status,
-      statusText: STATUS_CODES[status],
+      status: status          ,
+      statusText: STATUS_CODES[status          ],
       headers,
     })
   }
 }
 
-module.exports = { playbackInterceptor }
+export { playbackInterceptor }

package/dist/lib/recorder.d.ts

@@ -0,0 +1,13 @@
+import type { Definition } from './scope.ts';
+export interface RecorderOptions {
+    dont_print?: boolean;
+    output_objects?: boolean;
+    enable_reqheaders_recording?: boolean;
+    logging?: (content: string) => void;
+    use_separator?: boolean;
+}
+declare function record(recOptions?: boolean | RecorderOptions): void;
+declare function restore(): void;
+declare function clear(): void;
+declare function outputs(): string[] | Definition[];
+export { record, outputs, restore, clear };

package/{lib → dist/lib}/recorder.js

@@ -1,41 +1,47 @@
-'use strict'
-
-const { recorder: debug } = require('./debug')
-const querystring = require('node:querystring')
-const { inspect } = require('node:util')
-
-const common = require('./common')
-const { restoreOverriddenClientRequest } = require('./intercept')
-const { gzipSync, brotliCompressSync, deflateSync } = require('node:zlib')
-const {
-  default: nodeInterceptors,
-} = require('@mswjs/interceptors/presets/node')
+                                            
+
+                                  
+                      
+                          
+                                       
+                                     
+                         
+ 
+
+import { recorder as debug } from './debug.js'
+import querystring from 'node:querystring'
+import { inspect } from 'node:util'
+
+import * as common from './common.js'
+import { restoreOverriddenClientRequest } from './intercept.js'
+import { BatchInterceptor } from '@mswjs/interceptors'
+import { ClientRequestInterceptor } from '@mswjs/interceptors/ClientRequest'
+import { FetchInterceptor } from '@mswjs/interceptors/fetch'
+
 const SEPARATOR = '\n<<<<<<-- cut here -->>>>>>\n'
 let recordingInProgress = false
-let outputs = []
+let _outputs                             = []
 
-// TODO: don't reuse the nodeInterceptors, create new ones.
-const clientRequestInterceptor = nodeInterceptors[0]
-const fetchRequestInterceptor = nodeInterceptors[2]
+const interceptor = new BatchInterceptor({
+  name: 'intercept',
+  interceptors: [new ClientRequestInterceptor(), new FetchInterceptor()],
+})
 
-/**
- * @param {URL} url
- */
-function getScope(url) {
+function getScope(url     ) {
   return common.normalizeOrigin(url)
 }
 
-function getMethod(request) {
+function getMethod(request         ) {
   return request.method || 'GET'
 }
 
-function getBodyFromChunks(chunks, headers) {
+function getBodyFromChunks(chunks          , headers                      ) {
   // If we have headers and there is content-encoding it means that the body
   // shouldn't be merged but instead persisted as an array of hex strings so
   // that the response chunks can be mocked one by one.
   if (headers && common.isContentEncoded(headers)) {
     return {
-      body: chunks.map(chunk => chunk.toString('hex')),
+      body: chunks.map((chunk        ) => chunk.toString('hex')),
     }
   }
 
@@ -67,11 +73,10 @@ function getBodyFromChunks(chunks, headers) {
   }
 }
 
-/**
- * @param {Request} request
- * @param {Response} response
- */
-async function generateRequestAndResponseObject(request, response) {
+async function generateRequestAndResponseObject(
+  request         ,
+  response          ,
+) {
   const { body, isUtf8Representable } = getBodyFromChunks(
     [Buffer.from(await response.arrayBuffer())],
     Object.fromEntries(response.headers.entries()),
@@ -94,22 +99,20 @@ async function generateRequestAndResponseObject(request, response) {
   }
 }
 
-/**
- * @param {Request} request
- * @param {Response} response
- */
-async function generateRequestAndResponse(request, response) {
+async function generateRequestAndResponse(
+  request         ,
+  response          ,
+) {
   const url = new URL(request.url)
   const requestBody = getBodyFromChunks([
     Buffer.from(await request.arrayBuffer()),
   ]).body
   const responseBody = getBodyFromChunks(
     [Buffer.from(await response.arrayBuffer())],
-    response.headers,
+    response.headers       ,
   ).body
 
-  // Always encode the query parameters when recording.
-  const encodedQueryObj = {}
+  const encodedQueryObj                      = {}
 
   for (const [key, value] of Object.entries(
     querystring.parse(url.searchParams.toString()),
@@ -122,7 +125,7 @@ async function generateRequestAndResponse(request, response) {
     encodedQueryObj[formattedPair[0]] = formattedPair[1]
   }
 
-  const lines = []
+  const lines           = []
 
   // We want a leading newline.
   lines.push('')
@@ -151,7 +154,7 @@ async function generateRequestAndResponse(request, response) {
     lines.push(`  .query(${JSON.stringify(encodedQueryObj)})`)
   }
 
-  const statusCode = response.status.toString()
+  const statusCode = String(response.status)
   const stringifiedResponseBody = JSON.stringify(responseBody)
   const headers = inspect(Object.fromEntries(response.headers.entries()))
   lines.push(`  .reply(${statusCode}, ${stringifiedResponseBody}, ${headers});`)
@@ -174,7 +177,7 @@ const defaultRecordOptions = {
   use_separator: true,
 }
 
-function record(recOptions) {
+function record(recOptions                            ) {
   //  Trying to start recording with recording already in progress implies an error
   //  in the recording configuration (double recording makes no sense and used to lead
   //  to duplicates in output)
@@ -206,7 +209,10 @@ function record(recOptions) {
     use_separator: useSeparator,
   } = recOptions
 
-  debug(thisRecordingId, 'restoring overridden requests before new overrides')
+  debug(
+    String(thisRecordingId),
+    'restoring overridden requests before new overrides',
+  )
   //  To preserve backward compatibility (starting recording wasn't throwing if nock was already active)
   //  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
@@ -216,49 +222,16 @@ function record(recOptions) {
   restoreOverriddenClientRequest()
 
   //  We override the requests so that we can save information on them before executing.
-  clientRequestInterceptor.apply()
-  fetchRequestInterceptor.apply()
-  clientRequestInterceptor.on(
-    'response',
-    async function ({ request, response }) {
-      await recordResponse(request, response)
-    },
-  )
-  fetchRequestInterceptor.on(
-    'response',
-    async function ({ request, response }) {
-      // fetch decompresses the body automatically, so we need to recompress it
-      const codings =
-        response.headers
-          .get('content-encoding')
-          ?.toLowerCase()
-          .split(',')
-          .map(c => c.trim()) || []
-
-      let body = await response.arrayBuffer()
-      for (const coding of codings) {
-        if (coding === 'gzip') {
-          body = gzipSync(body)
-        } else if (coding === 'deflate') {
-          body = deflateSync(body)
-        } else if (coding === 'br') {
-          body = brotliCompressSync(body)
-        }
-      }
-
-      await recordResponse(request, new Response(body, response))
-    },
-  )
+  interceptor.apply()
+  interceptor.on('response', async function ({ request, response }) {
+    await recordResponse(request, response)
+  })
 
-  /**
-   * @param {Request} mswRequest
-   * @param {Response} mswResponse
-   */
-  async function recordResponse(mswRequest, mswResponse) {
+  async function recordResponse(mswRequest         , mswResponse          ) {
     const request = mswRequest.clone()
     const response = mswResponse.clone()
     debug(
-      thisRecordingId,
+      String(thisRecordingId),
       request.url.split(':', 1)[0],
       'intercepted request ended',
     )
@@ -279,7 +252,7 @@ function record(recOptions) {
     const generateFn = outputObjects
       ? generateRequestAndResponseObject
       : generateRequestAndResponse
-    let out = await generateFn(request, response)
+    let out      = await generateFn(request, response)
 
     debug('out:', out)
 
@@ -296,16 +269,16 @@ function record(recOptions) {
       return
     }
 
-    outputs.push(out)
+    _outputs.push(out)
 
     if (!dontPrint) {
       if (useSeparator) {
         if (typeof out !== 'string') {
           out = JSON.stringify(out, null, 2)
         }
-        logging(SEPARATOR + out + SEPARATOR)
+        ;(logging            )(SEPARATOR + out + SEPARATOR)
       } else {
-        logging(out)
+        ;(logging            )(out)
       }
     }
 
@@ -316,23 +289,21 @@ function record(recOptions) {
 // Restore *all* the overridden http/https modules' properties.
 function restore() {
   debug(
-    currentRecordingId,
+    String(currentRecordingId),
     'restoring all the overridden http/https properties',
   )
 
-  clientRequestInterceptor.dispose()
-  fetchRequestInterceptor.dispose()
+  interceptor.dispose()
   restoreOverriddenClientRequest()
   recordingInProgress = false
 }
 
 function clear() {
-  outputs = []
+  _outputs = []
 }
 
-module.exports = {
-  record,
-  outputs: () => outputs,
-  restore,
-  clear,
+function outputs()                          {
+  return _outputs                           
 }
+
+export { record, outputs, restore, clear }