nock 15.0.0 → 15.0.1

package/dist/lib/scope.d.ts

@@ -0,0 +1,59 @@
+import type { ReplyBody, ReplyHeaders, RequestBodyMatcher, RequestHeaderMatcher } from './interceptor.ts';
+export interface Options {
+    allowUnmocked?: boolean;
+    reqheaders?: Record<string, RequestHeaderMatcher>;
+    badheaders?: string[];
+    conditionally?: () => boolean;
+    filteringScope?: (scope: string) => boolean;
+    encodedQueryParams?: boolean;
+}
+export interface Definition {
+    scope: string | RegExp;
+    path: string | RegExp;
+    port?: number | string;
+    method?: string;
+    status?: number;
+    body?: RequestBodyMatcher;
+    reply?: string;
+    reqheaders?: Record<string, RequestHeaderMatcher>;
+    badheaders?: string[];
+    rawHeaders?: ReplyHeaders;
+    response?: ReplyBody;
+    responseIsBinary?: boolean;
+    headers?: ReplyHeaders;
+    options?: Options;
+}
+import { EventEmitter } from 'node:events';
+import { Interceptor } from './interceptor.ts';
+declare class Scope extends EventEmitter {
+    constructor(basePath: string | RegExp | URL, options?: Options);
+    add(key: string, interceptor: Interceptor): void;
+    remove(key: string, interceptor: Interceptor): void;
+    intercept(uri: string | RegExp | ((path: string) => boolean), method: string, requestBody?: RequestBodyMatcher, interceptorOptions?: Options): Interceptor;
+    get(uri: string | RegExp | ((path: string) => boolean), requestBody?: RequestBodyMatcher, options?: Options): Interceptor;
+    post(uri: string | RegExp | ((path: string) => boolean), requestBody?: RequestBodyMatcher, options?: Options): Interceptor;
+    put(uri: string | RegExp | ((path: string) => boolean), requestBody?: RequestBodyMatcher, options?: Options): Interceptor;
+    head(uri: string | RegExp | ((path: string) => boolean), requestBody?: RequestBodyMatcher, options?: Options): Interceptor;
+    patch(uri: string | RegExp | ((path: string) => boolean), requestBody?: RequestBodyMatcher, options?: Options): Interceptor;
+    merge(uri: string | RegExp | ((path: string) => boolean), requestBody?: RequestBodyMatcher, options?: Options): Interceptor;
+    delete(uri: string | RegExp | ((path: string) => boolean), requestBody?: RequestBodyMatcher, options?: Options): Interceptor;
+    options(uri: string | RegExp | ((path: string) => boolean), requestBody?: RequestBodyMatcher, options?: Options): Interceptor;
+    pendingMocks(): string[];
+    activeMocks(): string[];
+    isDone(): boolean;
+    done(): void;
+    buildFilter(): any;
+    filteringPath(): this;
+    filteringRequestBody(): this;
+    matchHeader(name: string, value: RequestHeaderMatcher): this;
+    defaultReplyHeaders(headers: ReplyHeaders): this;
+    persist(flag?: boolean): this;
+    shouldPersist(): boolean;
+    replyContentLength(): this;
+    replyDate(d?: Date): this;
+    clone(): Scope;
+}
+declare function loadDefs(path: string): any;
+declare function load(path: string): Scope[];
+declare function define(nockDefs: Record<string, any>[]): Scope[];
+export { Scope, load, loadDefs, define };

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

@@ -1,21 +1,45 @@
-'use strict'
-
-/**
- * @module nock/scope
- */
-const fs = require('node:fs')
-const { scopeDebuglog } = require('./debug')
-const { addInterceptor, isOn } = require('./intercept')
-const common = require('./common')
-const assert = require('node:assert')
-const { EventEmitter } = require('node:events')
-const Interceptor = require('./interceptor')
-
-/**
- * Normalizes the passed url for consistent internal processing
- * @param {string|URL} u
- */
-function normalizeUrl(u) {
+             
+            
+               
+                     
+                       
+                         
+
+                          
+                         
+                                                   
+                       
+                               
+                                             
+                              
+ 
+
+                             
+                        
+                       
+                        
+                 
+                 
+                           
+                
+                                                   
+                       
+                           
+                      
+                            
+                        
+                   
+ 
+
+import fs from 'node:fs'
+import { scopeDebuglog } from './debug.js'
+import { addInterceptor, isOn } from './intercept.js'
+import * as common from './common.js'
+import assert from 'node:assert'
+import { EventEmitter } from 'node:events'
+import { Interceptor } from './interceptor.js'
+
+function normalizeUrl(u              ) {
   if (typeof u === 'string') {
     // If the url is invalid, let the URL library report it
     return normalizeUrl(new URL(u))
@@ -47,19 +71,41 @@ function normalizeUrl(u) {
   }
 }
 
-/**
- * @param  {string|RegExp|URL} basePath
- * @param  {Object}   options
- * @param  {boolean}  options.allowUnmocked
- * @param  {string[]} options.badheaders
- * @param  {function} options.conditionally
- * @param  {boolean}  options.encodedQueryParams
- * @param  {function} options.filteringScope
- * @param  {Object}   options.reqheaders
- * @constructor
- */
 class Scope extends EventEmitter {
-  constructor(basePath, options) {
+  /** @internal */
+                                                          
+  /** @internal */
+                                     
+  /** @internal */
+                                                                  
+  /** @internal */
+                                       
+                                                  
+          
+  /** @internal */
+                                                      
+  /** @internal */
+                                                     
+  /** @internal */
+                                       
+  /** @internal */
+                           
+  /** @internal */
+                             
+  /** @internal */
+                           
+  /** @internal */
+                                   
+  /** @internal */
+                              
+  /** @internal */
+                   
+  /** @internal */
+                                     
+  /** @internal */
+                                          
+
+  constructor(basePath                       , options          ) {
     super()
 
     this.keyedInterceptors = {}
@@ -72,7 +118,7 @@ class Scope extends EventEmitter {
     this._persist = false
     this.contentLen = false
     this.date = null
-    this.basePath = basePath
+    this.basePath = basePath                   
     this.basePathname = ''
     this.port = null
     this._defaultReplyHeaders = []
@@ -80,7 +126,7 @@ class Scope extends EventEmitter {
     let logNamespace = String(basePath)
 
     if (!(basePath instanceof RegExp)) {
-      this.urlParts = normalizeUrl(basePath)
+      this.urlParts = normalizeUrl(basePath                )
       this.port = this.urlParts.port
       this.basePathname = this.urlParts.pathname.replace(/\/$/, '')
       this.basePath = `${this.urlParts.protocol}//${this.urlParts.hostname}:${this.port}`
@@ -90,21 +136,21 @@ class Scope extends EventEmitter {
     this.logger = scopeDebuglog(logNamespace)
   }
 
-  add(key, interceptor) {
+  add(key        , interceptor             ) {
     if (!(key in this.keyedInterceptors)) {
       this.keyedInterceptors[key] = []
     }
     this.keyedInterceptors[key].push(interceptor)
     addInterceptor(
-      this.basePath,
+      this.basePath          ,
       interceptor,
       this,
       this.scopeOptions,
-      this.urlParts.hostname,
+      this.urlParts.hostname          ,
     )
   }
 
-  remove(key, interceptor) {
+  remove(key        , interceptor             ) {
     if (this._persist) {
       return
     }
@@ -117,7 +163,12 @@ class Scope extends EventEmitter {
     }
   }
 
-  intercept(uri, method, requestBody, interceptorOptions) {
+  intercept(
+    uri                                               ,
+    method        ,
+    requestBody                     ,
+    interceptorOptions          ,
+  )              {
     const ic = new Interceptor(
       this,
       uri,
@@ -130,53 +181,83 @@ class Scope extends EventEmitter {
     return ic
   }
 
-  get(uri, requestBody, options) {
+  get(
+    uri                                               ,
+    requestBody                     ,
+    options          ,
+  )              {
     return this.intercept(uri, 'GET', requestBody, options)
   }
 
-  post(uri, requestBody, options) {
+  post(
+    uri                                               ,
+    requestBody                     ,
+    options          ,
+  )              {
     return this.intercept(uri, 'POST', requestBody, options)
   }
 
-  put(uri, requestBody, options) {
+  put(
+    uri                                               ,
+    requestBody                     ,
+    options          ,
+  )              {
     return this.intercept(uri, 'PUT', requestBody, options)
   }
 
-  head(uri, requestBody, options) {
+  head(
+    uri                                               ,
+    requestBody                     ,
+    options          ,
+  )              {
     return this.intercept(uri, 'HEAD', requestBody, options)
   }
 
-  patch(uri, requestBody, options) {
+  patch(
+    uri                                               ,
+    requestBody                     ,
+    options          ,
+  )              {
     return this.intercept(uri, 'PATCH', requestBody, options)
   }
 
-  merge(uri, requestBody, options) {
+  merge(
+    uri                                               ,
+    requestBody                     ,
+    options          ,
+  )              {
     return this.intercept(uri, 'MERGE', requestBody, options)
   }
 
-  delete(uri, requestBody, options) {
+  delete(
+    uri                                               ,
+    requestBody                     ,
+    options          ,
+  )              {
     return this.intercept(uri, 'DELETE', requestBody, options)
   }
 
-  options(uri, requestBody, options) {
+  options(
+    uri                                               ,
+    requestBody                     ,
+    options          ,
+  )              {
     return this.intercept(uri, 'OPTIONS', requestBody, options)
   }
 
   // Returns the list of keys for non-optional Interceptors that haven't been completed yet.
-  // TODO: This assumes that completed mocks are removed from the keyedInterceptors list
-  // (when persistence is off). We should change that (and this) in future.
   pendingMocks() {
-    return this.activeMocks().filter(key =>
-      this.keyedInterceptors[key].some(({ interceptionCounter, optional }) => {
-        const persistedAndUsed = this._persist && interceptionCounter > 0
-        return !persistedAndUsed && !optional
-      }),
+    return this.activeMocks().filter((key        ) =>
+      this.keyedInterceptors[key].some(
+        ({ interceptionCounter, optional }             ) => {
+          const persistedAndUsed = this._persist && interceptionCounter > 0
+          return !persistedAndUsed && !optional
+        },
+      ),
     )
   }
 
   // Returns all keyedInterceptors that are active.
-  // This includes incomplete interceptors, persisted but complete interceptors, and
-  // optional interceptors, but not non-persisted and completed interceptors.
   activeMocks() {
     return Object.keys(this.keyedInterceptors)
   }
@@ -197,16 +278,12 @@ class Scope extends EventEmitter {
   }
 
   buildFilter() {
-    const filteringArguments = arguments
+    const filteringArguments = Array.from(arguments)         
 
     if (arguments[0] instanceof RegExp) {
-      return function (candidate) {
+      return function (candidate        ) {
         /* istanbul ignore if */
         if (typeof candidate !== 'string') {
-          // Given the way nock is written, it seems like `candidate` will always
-          // be a string, regardless of what options might be passed to it.
-          // However the code used to contain a truthiness test of `candidate`.
-          // The check is being preserved for now.
           throw Error(
             `Nock internal assertion failed: typeof candidate is ${typeof candidate}. If you encounter this error, please report it as a bug.`,
           )
@@ -219,7 +296,7 @@ class Scope extends EventEmitter {
   }
 
   filteringPath() {
-    this.transformPathFunction = this.buildFilter.apply(this, arguments)
+    this.transformPathFunction = this.buildFilter.apply(this, arguments       )
     if (!this.transformPathFunction) {
       throw new Error(
         'Invalid arguments: filtering path should be a function or a regular expression',
@@ -229,7 +306,10 @@ class Scope extends EventEmitter {
   }
 
   filteringRequestBody() {
-    this.transformRequestBodyFunction = this.buildFilter.apply(this, arguments)
+    this.transformRequestBodyFunction = this.buildFilter.apply(
+      this,
+      arguments       ,
+    )
     if (!this.transformRequestBodyFunction) {
       throw new Error(
         'Invalid arguments: filtering request body should be a function or a regular expression',
@@ -238,13 +318,13 @@ class Scope extends EventEmitter {
     return this
   }
 
-  matchHeader(name, value) {
+  matchHeader(name        , value                      ) {
     //  We use lower-case header field names throughout Nock.
     this.matchHeaders.push({ name: name.toLowerCase(), value })
     return this
   }
 
-  defaultReplyHeaders(headers) {
+  defaultReplyHeaders(headers              ) {
     this._defaultReplyHeaders = common.headersInputToRawArray(headers)
     return this
   }
@@ -257,10 +337,6 @@ class Scope extends EventEmitter {
     return this
   }
 
-  /**
-   * @private
-   * @returns {boolean}
-   */
   shouldPersist() {
     return this._persist
   }
@@ -270,7 +346,7 @@ class Scope extends EventEmitter {
     return this
   }
 
-  replyDate(d) {
+  replyDate(d       ) {
     this.date = d || new Date()
     return this
   }
@@ -280,20 +356,20 @@ class Scope extends EventEmitter {
   }
 }
 
-function loadDefs(path) {
+function loadDefs(path        ) {
   if (!fs) {
     throw new Error('No fs')
   }
 
-  const contents = fs.readFileSync(path)
+  const contents = fs.readFileSync(path)                     
   return JSON.parse(contents)
 }
 
-function load(path) {
+function load(path        ) {
   return define(loadDefs(path))
 }
 
-function getStatusFromDefinition(nockDef) {
+function getStatusFromDefinition(nockDef                     ) {
   // Backward compatibility for when `status` was encoded as string in `reply`.
   if (nockDef.reply !== undefined) {
     const parsedReply = parseInt(nockDef.reply, 10)
@@ -308,11 +384,11 @@ function getStatusFromDefinition(nockDef) {
   return nockDef.status || DEFAULT_STATUS_OK
 }
 
-function getScopeFromDefinition(nockDef) {
+function getScopeFromDefinition(nockDef                     ) {
   //  Backward compatibility for when `port` was part of definition.
   if (nockDef.port !== undefined) {
     //  Include `port` into scope if it doesn't exist.
-    const url = URL.parse(nockDef.scope)
+    const url = URL.parse(nockDef.scope)       
 
     if (url.port === '') {
       return `${nockDef.scope}:${nockDef.port}`
@@ -328,7 +404,7 @@ function getScopeFromDefinition(nockDef) {
   return nockDef.scope
 }
 
-function tryJsonParse(string) {
+function tryJsonParse(string        ) {
   try {
     return JSON.parse(string)
   } catch {
@@ -336,10 +412,10 @@ function tryJsonParse(string) {
   }
 }
 
-function define(nockDefs) {
-  const scopes = []
+function define(nockDefs                       ) {
+  const scopes          = []
 
-  nockDefs.forEach(function (nockDef) {
+  nockDefs.forEach(function (nockDef                     ) {
     const nscope = getScopeFromDefinition(nockDef)
     const npath = nockDef.path
     if (!nockDef.method) {
@@ -377,13 +453,13 @@ function define(nockDefs) {
 
     // If request headers were specified filter by them.
     Object.entries(reqheaders).forEach(([fieldName, value]) => {
-      scope.matchHeader(fieldName, value)
+      scope.matchHeader(fieldName, value                        )
     })
 
     const acceptableFilters = ['filteringRequestBody', 'filteringPath']
     acceptableFilters.forEach(filter => {
       if (nockDef[filter]) {
-        scope[filter](nockDef[filter])
+        ;(scope       )[filter](nockDef[filter])
       }
     })
 
@@ -397,9 +473,4 @@ function define(nockDefs) {
   return scopes
 }
 
-module.exports = {
-  Scope,
-  load,
-  loadDefs,
-  define,
-}
+export { Scope, load, loadDefs, define }

package/dist/lib/stringify.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @module stringify
+ * @private
+ * Safe JSON.stringify that handles circular references.
+ * @see https://github.com/moll/json-stringify-safe/blob/02cfafd45f06d076ac4bf0dd28be6738a07a72f9/stringify.js
+ * @license
+ * The ISC License
+ *
+ * Copyright (c) Isaac Z. Schlueter and Contributors
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+ * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+declare function stringify(obj: any): string;
+export default stringify;

package/dist/lib/stringify.js

@@ -0,0 +1,50 @@
+/**
+ * @module stringify
+ * @private
+ * Safe JSON.stringify that handles circular references.
+ * @see https://github.com/moll/json-stringify-safe/blob/02cfafd45f06d076ac4bf0dd28be6738a07a72f9/stringify.js
+ * @license
+ * The ISC License
+ *
+ * Copyright (c) Isaac Z. Schlueter and Contributors
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+ * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+function stringify(obj     ) {
+  return JSON.stringify(obj, safeReplacer())
+}
+
+function cycleReplacer(stack       , keys          , value     ) {
+  if (stack[0] === value) return '[Circular ~]'
+  return `[Circular ~.${keys.slice(0, stack.indexOf(value)).join('.')}]`
+}
+
+function safeReplacer(stack        = [], keys           = []) {
+  return function (           key        , value     ) {
+    if (stack.length > 0) {
+      const thisPos = stack.indexOf(this)
+      ~thisPos ? stack.splice(thisPos + 1) : stack.push(this)
+      ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key)
+      if (~stack.indexOf(value)) {
+        value = cycleReplacer(stack, keys, value)
+      }
+    } else {
+      stack.push(value)
+    }
+
+    return value
+  }
+}
+
+export default stringify

package/dist/lib/utils/node/index.d.ts

@@ -0,0 +1,4 @@
+import { Readable as ReadableStream } from 'node:stream';
+declare function getGetRequestBody(request: Request): ReadableStream;
+declare function setGetRequestBody(request: Request, body: ArrayBuffer): void;
+export { getGetRequestBody, setGetRequestBody };

package/dist/lib/utils/node/index.js

@@ -0,0 +1,16 @@
+import { Readable as ReadableStream } from 'node:stream'
+
+const kGetRequestBody                = Symbol('kGetRequestBody')       
+
+function getGetRequestBody(request         ) {
+  if (request.method !== 'GET') {
+    throw new Error('The request method must be GET')
+  }
+  return ReadableStream.from(Reflect.get(request, kGetRequestBody))
+}
+
+function setGetRequestBody(request         , body             ) {
+  Reflect.set(request, kGetRequestBody, Buffer.from(body))
+}
+
+export { getGetRequestBody, setGetRequestBody }

package/package.json

@@ -7,7 +7,7 @@
     "testing",
     "isolation"
   ],
-  "version": "15.0.0",
+  "version": "15.0.1",
   "author": "Pedro Teixeira <pedro.teixeira@gmail.com>",
   "repository": {
     "type": "git",
@@ -17,21 +17,26 @@
     "url": "https://github.com/nock/nock/issues"
   },
   "engines": {
-    "node": ">=18.20.0 <20 || >=20.12.1"
+    "node": ">=20.12.1"
+  },
+  "main": "./dist/index.js",
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
   },
-  "main": "./index.js",
-  "types": "types",
   "dependencies": {
-    "@mswjs/interceptors": "^0.39.5",
-    "json-stringify-safe": "^5.0.1"
+    "@mswjs/interceptors": "^0.44.0"
   },
   "devDependencies": {
-    "@definitelytyped/dtslint": "^0.0.163",
     "@eslint/js": "^9.27.0",
-    "@jest/globals": "^29.7.0",
     "@sinonjs/fake-timers": "^11.2.2",
     "@types/node": "^22.15.3",
     "assert-rejects": "^1.0.0",
+    "c8": "^11.0.0",
     "chai": "^4.1.2",
     "dirty-chai": "^2.0.1",
     "eslint": "^9.27.0",
@@ -41,35 +46,33 @@
     "form-data": "^4.0.0",
     "globals": "^16.1.0",
     "got": "^11.8.6",
-    "jest": "^29.7.0",
     "mocha": "^11.7.2",
     "npm-run-all": "^4.1.5",
-    "nyc": "^15.0.0",
-    "prettier": "3.2.5",
-    "proxyquire": "^2.1.0",
+    "prettier": "3.6.2",
     "rimraf": "^3.0.0",
-    "semantic-release": "^24.1.0",
+    "semantic-release": "^25.0.3",
     "sinon": "^17.0.1",
     "sinon-chai": "^3.7.0",
-    "typescript": "^5.0.4",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.58.2",
     "undici": "^7.9.0"
   },
   "scripts": {
     "format:fix": "prettier --write '**/*.{js,json,md,ts,yml,yaml}'",
     "format": "prettier --check '**/*.{js,json,md,ts,yml,yaml}'",
     "lint": "run-p lint:js lint:ts",
-    "lint:js": "eslint --cache --cache-location './.cache/eslint' '**/*.js'",
-    "lint:js:fix": "eslint --cache --cache-location './.cache/eslint' --fix '**/*.js'",
-    "lint:ts": "dtslint --expectOnly types",
-    "test": "nyc --reporter=lcov --reporter=text mocha --recursive tests",
+    "lint:js": "eslint --cache --cache-location './.cache/eslint' '**/*.{js,ts}'",
+    "lint:fix": "eslint --cache --cache-location './.cache/eslint' --fix '**/*.{js,ts}'",
+    "lint:ts": "tsc --noEmit",
+    "build": "rimraf dist && node scripts/build.js && tsc -p tsconfig.build.json",
+    "test": "c8 --reporter=lcov --reporter=text mocha --recursive tests",
     "test:coverage": "open coverage/lcov-report/index.html",
-    "test:jest": "jest tests_jest --detectLeaks"
+    "test:leak": "node --expose-gc scripts/test-leak.js",
+    "test:build": "npm run build && node scripts/test-build.js"
   },
   "license": "MIT",
   "files": [
-    "index.js",
-    "lib",
-    "types/index.d.ts"
+    "dist"
   ],
   "release": {
     "branches": [