nock 15.0.0-beta.10 → 15.0.0-beta.12

package/dist/index.d.ts

@@ -0,0 +1,60 @@
+import type { Options, Definition } from './lib/scope.ts';
+import type { BackOptions, BackContext, BackMode, Back, InterceptorSurface } from './lib/back.ts';
+import type { RecorderOptions } from './lib/recorder.ts';
+import type { InterceptorMatchResult } from './lib/global_emitter.ts';
+import type { DataMatcher, DataMatcherArray, DataMatcherMap, RequestBodyMatcher, RequestHeaderMatcher, Body, ReplyBody, ReplyHeaderFunction, ReplyHeaderValue, ReplyHeaders, StatusCode, ReplyFnResult, Interceptor } from './lib/interceptor.ts';
+import type { Scope } from './lib/scope.ts';
+import { removeAll } from './lib/intercept.ts';
+declare function nock(basePath: string | RegExp | URL, options?: Options): Scope;
+declare namespace nock {
+    var activate: typeof import("./lib/intercept.ts").activate;
+    var isActive: () => boolean;
+    var isDone: typeof import("./lib/intercept.ts").isDone;
+    var pendingMocks: typeof import("./lib/intercept.ts").pendingMocks;
+    var activeMocks: typeof import("./lib/intercept.ts").activeMocks;
+    var removeInterceptor: typeof import("./lib/intercept.ts").removeInterceptor;
+    var disableNetConnect: typeof import("./lib/intercept.ts").disableNetConnect;
+    var enableNetConnect: typeof import("./lib/intercept.ts").enableNetConnect;
+    var cleanAll: typeof removeAll;
+    var abortPendingRequests: typeof import("./lib/common.ts").removeAllTimers;
+    var load: typeof import("./lib/scope.ts").load;
+    var loadDefs: typeof import("./lib/scope.ts").loadDefs;
+    var define: typeof import("./lib/scope.ts").define;
+    var emitter: import("events")<{
+        'no match': [req: Request, interceptorResults?: InterceptorMatchResult[]];
+    }>;
+    var recorder: {
+        rec: typeof import("./lib/recorder.ts").record;
+        clear: typeof import("./lib/recorder.ts").clear;
+        play: typeof import("./lib/recorder.ts").outputs;
+    };
+    var restore: typeof import("./lib/recorder.ts").restore;
+    var back: typeof import("./lib/back.ts").default;
+    var getGetRequestBody: typeof import("./lib/utils/node/index.ts").getGetRequestBody;
+}
+export default nock;
+declare namespace nock {
+    export type { Scope };
+    export type { Interceptor };
+    export type { Options };
+    export type { Definition };
+    export type { BackMode };
+    export type { BackContext };
+    export type { BackOptions };
+    export type { RecorderOptions };
+    export type { InterceptorSurface };
+    export type { InterceptorMatchResult };
+    export type { DataMatcher };
+    export type { DataMatcherArray };
+    export type { DataMatcherMap };
+    export type { RequestBodyMatcher };
+    export type { RequestHeaderMatcher };
+    export type { Body };
+    export type { ReplyBody };
+    export type { ReplyHeaderFunction };
+    export type { ReplyHeaderValue };
+    export type { ReplyHeaders };
+    export type { StatusCode };
+    export type { ReplyFnResult };
+    export type { Back };
+}

package/dist/index.js

@@ -0,0 +1,109 @@
+                                                         
+             
+              
+              
+           
+       
+                     
+                      
+                                                        
+                                                                     
+             
+              
+                   
+                 
+                     
+                       
+       
+            
+                      
+                   
+               
+             
+                
+              
+                             
+                                           
+
+import back from './lib/back.js'
+import emitter from './lib/global_emitter.js'
+import {
+  activate,
+  isActive,
+  isDone,
+  isOn,
+  pendingMocks,
+  activeMocks,
+  removeInterceptor,
+  disableNetConnect,
+  enableNetConnect,
+  removeAll,
+  abortPendingRequests,
+} from './lib/intercept.js'
+import * as recorder from './lib/recorder.js'
+import { Scope as ScopeClass, load, loadDefs, define } from './lib/scope.js'
+import { getGetRequestBody } from './lib/utils/node/index.js'
+
+function nock(basePath                       , options          ) {
+  return new ScopeClass(basePath, options)
+}
+
+nock.activate = activate
+nock.isActive = isActive
+nock.isDone = isDone
+nock.pendingMocks = pendingMocks
+nock.activeMocks = activeMocks
+nock.removeInterceptor = removeInterceptor
+nock.disableNetConnect = disableNetConnect
+nock.enableNetConnect = enableNetConnect
+nock.cleanAll = removeAll
+nock.abortPendingRequests = abortPendingRequests
+nock.load = load
+nock.loadDefs = loadDefs
+nock.define = define
+nock.emitter = emitter
+nock.recorder = {
+  rec: recorder.record,
+  clear: recorder.clear,
+  play: recorder.outputs,
+}
+nock.restore = recorder.restore
+nock.back = back
+nock.getGetRequestBody = getGetRequestBody
+
+export default nock
+
+// Re-export types into the nock namespace so consumers can use nock.Scope, nock.Options, etc.
+                        
+                       
+                             
+                         
+                            
+                          
+                             
+                             
+                                 
+                                    
+                                        
+                             
+                                  
+                                
+                                    
+                                      
+                      
+                           
+                                     
+                                  
+                              
+                            
+                               
+                      
+ 
+
+// We always activate Nock on import, overriding the globals.
+// Setting the Back mode "activates" Nock by overriding the global entries in the `http/s` modules.
+// If Nock Back is configured, we need to honor that setting for backward compatibility,
+// otherwise we rely on Nock Back's default initializing side effect.
+if (isOn()) {
+  back.setMode(process.env.NOCK_BACK_MODE || 'dryrun')
+}

package/dist/lib/back.d.ts

@@ -0,0 +1,44 @@
+import type { Scope } from './scope.ts';
+import type { Definition } from './scope.ts';
+import type { RecorderOptions } from './recorder.ts';
+export type BackMode = 'wild' | 'dryrun' | 'record' | 'update' | 'lockdown';
+export interface BackOptions {
+    before?: (def: Definition) => void;
+    after?: (scope: Scope) => void;
+    afterRecord?: (defs: Definition[]) => Definition[] | string;
+    recorder?: RecorderOptions;
+}
+declare namespace Back {
+    let fixtures: string | null;
+    let currentMode: string;
+}
+declare function Back(fixtureName: string, nockedFn: (nockDone: () => void) => void): void;
+declare function Back(fixtureName: string, options: BackOptions, nockedFn: (nockDone: () => void) => void): void;
+declare function Back(fixtureName: string, options?: BackOptions): Promise<{
+    nockDone: () => void;
+    context: BackContext;
+}>;
+declare namespace Back {
+    var setMode: (mode: string) => void;
+}
+declare function load(fixture?: string, options?: BackOptions | Record<string, any>): {
+    isLoaded: boolean;
+    isRecording: boolean;
+    scopes: Scope[];
+    assertScopesFinished: () => void;
+    query: () => {
+        method: string;
+        uri: string | RegExp | ((path: string) => boolean);
+        basePath: string | RegExp;
+        path: string | RegExp | ((path: string) => boolean);
+        queries: boolean | Record<string, any> | ((queryObject: Record<string, any>) => boolean) | null;
+        counter: number;
+        body: any;
+        statusCode: number | null | undefined;
+        optional: boolean;
+    }[];
+};
+export type BackContext = Omit<ReturnType<typeof load>, 'isRecording'>;
+export type InterceptorSurface = ReturnType<BackContext['query']>[number];
+export type Back = typeof Back;
+export default Back;

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

@@ -1,42 +1,62 @@
-'use strict'
-
-const fs = require('node:fs')
-const assert = require('node:assert')
-const recorder = require('./recorder')
-const {
+                                       
+                                            
+                                                   
+                                                    
+
+                                                                           
+
+                              
+                                    
+                                
+                                                             
+                            
+ 
+
+                            
+                   
+                                              
+                                                               
+ 
+
+import fs from 'node:fs'
+import assert from 'node:assert'
+import * as recorder from './recorder.js'
+import {
   activate,
   disableNetConnect,
   enableNetConnect,
-  removeAll: cleanAll,
-} = require('./intercept')
-const { loadDefs, define } = require('./scope')
-const { back: debug } = require('./debug')
-const { format } = require('node:util')
-const path = require('node:path')
-
-let _mode = null
-
-/**
- * nock the current function with the fixture given
- *
- * @param {string}   fixtureName  - the name of the fixture, e.x. 'foo.json'
- * @param {object}   options      - [optional] extra options for nock with, e.x. `{ assert: true }`
- * @param {function} nockedFn     - [optional] callback function to be executed with the given fixture being loaded;
- *                                  if defined the function will be called with context `{ scopes: loaded_nocks || [] }`
- *                                  set as `this` and `nockDone` callback function as first and only parameter;
- *                                  if not defined a promise resolving to `{nockDone, context}` where `context` is
- *                                  aforementioned `{ scopes: loaded_nocks || [] }`
- *
- * List of options:
- *
- * @param {function} before       - a preprocessing function, gets called before nock.define
- * @param {function} after        - a postprocessing function, gets called after nock.define
- * @param {function} afterRecord  - a postprocessing function, gets called after recording. Is passed the array
- *                                  of scopes recorded and should return the array scopes to save to the fixture
- * @param {function} recorder     - custom options to pass to the recorder
- *
- */
-function Back(fixtureName, options, nockedFn) {
+  removeAll as cleanAll,
+} from './intercept.js'
+import { loadDefs, define } from './scope.js'
+import { back as debug } from './debug.js'
+import { format } from 'node:util'
+import path from 'node:path'
+
+let _mode                          = null
+
+                        
+                             
+                         
+ 
+
+              
+                      
+                                           
+       
+              
+                      
+                       
+                                           
+       
+              
+                      
+                        
+                                                          
+function Back(
+  fixtureName        ,
+  options                                                 ,
+  nockedFn                                 ,
+) {
   if (!Back.fixtures) {
     throw new Error(
       'Back requires nock.back.fixtures to be set\n' +
@@ -60,13 +80,13 @@ function Back(fixtureName, options, nockedFn) {
     }
   }
 
-  _mode.setup()
+  ;(_mode                    ).setup()
 
-  const fixture = path.join(Back.fixtures, fixtureName)
-  const context = _mode.start(fixture, options)
+  const fixture = path.join(Back.fixtures          , fixtureName)
+  const context = (_mode                    ).start(fixture, options)
 
   const nockDone = function () {
-    _mode.finish(fixture, options, context)
+    ;(_mode                    ).finish(fixture, options, context)
   }
 
   debug('context:', context)
@@ -91,7 +111,7 @@ const wild = {
   },
 
   start: function () {
-    return load() // don't load anything but get correct context
+    return load(undefined, undefined) // don't load anything but get correct context
   },
 
   finish: function () {
@@ -108,7 +128,7 @@ const dryrun = {
     enableNetConnect()
   },
 
-  start: function (fixture, options) {
+  start: function (fixture        , options             ) {
     const contexts = load(fixture, options)
 
     enableNetConnect()
@@ -129,7 +149,7 @@ const record = {
     disableNetConnect()
   },
 
-  start: function (fixture, options) {
+  start: function (fixture        , options                     ) {
     if (!fs) {
       throw new Error('no fs')
     }
@@ -148,20 +168,24 @@ const record = {
     return context
   },
 
-  finish: function (fixture, options, context) {
+  finish: function (
+    fixture        ,
+    options             ,
+    context                         ,
+  ) {
     if (context.isRecording) {
-      let outputs = recorder.outputs()
+      let outputs      = recorder.outputs()
 
       if (typeof options.afterRecord === 'function') {
         outputs = options.afterRecord(outputs)
       }
 
-      outputs =
+      const data         =
         typeof outputs === 'string' ? outputs : JSON.stringify(outputs, null, 4)
-      debug('recorder outputs:', outputs)
+      debug('recorder outputs:', data)
 
       fs.mkdirSync(path.dirname(fixture), { recursive: true })
-      fs.writeFileSync(fixture, outputs)
+      fs.writeFileSync(fixture, data)
     }
   },
 }
@@ -175,7 +199,7 @@ const update = {
     disableNetConnect()
   },
 
-  start: function (fixture, options) {
+  start: function (fixture        , options             ) {
     if (!fs) {
       throw new Error('no fs')
     }
@@ -191,19 +215,19 @@ const update = {
     return context
   },
 
-  finish: function (fixture, options) {
-    let outputs = recorder.outputs()
+  finish: function (fixture        , options             ) {
+    let outputs      = recorder.outputs()
 
     if (typeof options.afterRecord === 'function') {
       outputs = options.afterRecord(outputs)
     }
 
-    outputs =
+    const data         =
       typeof outputs === 'string' ? outputs : JSON.stringify(outputs, null, 4)
-    debug('recorder outputs:', outputs)
+    debug('recorder outputs:', data)
 
     fs.mkdirSync(path.dirname(fixture), { recursive: true })
-    fs.writeFileSync(fixture, outputs)
+    fs.writeFileSync(fixture, data)
   },
 }
 
@@ -216,7 +240,7 @@ const lockdown = {
     disableNetConnect()
   },
 
-  start: function (fixture, options) {
+  start: function (fixture        , options             ) {
     return load(fixture, options)
   },
 
@@ -225,15 +249,17 @@ const lockdown = {
   },
 }
 
-function load(fixture, options) {
+function load(fixture         , options                                    ) {
   const context = {
-    scopes: [],
+    isLoaded: false,
+    isRecording: false,
+    scopes: []           ,
     assertScopesFinished: function () {
       assertScopes(this.scopes, fixture)
     },
     query: function () {
-      const nested = this.scopes.map(scope =>
-        scope.interceptors.map(interceptor => ({
+      return this.scopes.flatMap((scope       ) =>
+        scope.interceptors.map((interceptor             ) => ({
           method: interceptor.method,
           uri: interceptor.uri,
           basePath: interceptor.basePath,
@@ -245,17 +271,16 @@ function load(fixture, options) {
           optional: interceptor.optional,
         })),
       )
-
-      return [].concat.apply([], nested)
     },
   }
 
   if (fixture && fixtureExists(fixture)) {
     let scopes = loadDefs(fixture)
-    applyHook(scopes, options.before)
+
+    applyHook(scopes, options?.before)
 
     scopes = define(scopes)
-    applyHook(scopes, options.after)
+    applyHook(scopes, options?.after)
 
     context.scopes = scopes
     context.isLoaded = true
@@ -264,21 +289,25 @@ function load(fixture, options) {
   return context
 }
 
-function removeFixture(fixture) {
+                                                                      
+                                                                         
+
+function removeFixture(fixture        ) {
   const context = {
-    scopes: [],
-    assertScopesFinished: function () {},
+    scopes: []           ,
+    assertScopesFinished: () => {},
+    isLoaded: false,
+    isRecording: false,
   }
 
   if (fixture && fixtureExists(fixture)) {
     /* istanbul ignore next - fs.unlinkSync is for node 10 support */
     fs.rmSync ? fs.rmSync(fixture) : fs.unlinkSync(fixture)
   }
-  context.isLoaded = false
   return context
 }
 
-function applyHook(scopes, fn) {
+function applyHook(items       , fn                      ) {
   if (!fn) {
     return
   }
@@ -287,10 +316,10 @@ function applyHook(scopes, fn) {
     throw new Error('processing hooks must be a function')
   }
 
-  scopes.forEach(fn)
+  items.forEach(fn       )
 }
 
-function fixtureExists(fixture) {
+function fixtureExists(fixture        ) {
   if (!fs) {
     throw new Error('no fs')
   }
@@ -298,35 +327,31 @@ function fixtureExists(fixture) {
   return fs.existsSync(fixture)
 }
 
-function assertScopes(scopes, fixture) {
+function assertScopes(scopes         , fixture         ) {
   const pending = scopes
-    .filter(scope => !scope.isDone())
-    .map(scope => scope.pendingMocks())
+    .filter((scope       ) => !scope.isDone())
+    .map((scope       ) => scope.pendingMocks())
 
   if (pending.length) {
     assert.fail(
       format(
         '%j was not used, consider removing %s to rerecord fixture',
-        [].concat(...pending),
+        ([]            ).concat(...pending),
         fixture,
       ),
     )
   }
 }
 
-const Modes = {
+const Modes                                   = {
   wild, // all requests go out to the internet, dont replay anything, doesnt record anything
-
   dryrun, // use recorded nocks, allow http calls, doesnt record anything, useful for writing new tests (default)
-
   record, // use recorded nocks, record new nocks
-
   update, // allow http calls, record all nocks, don't use recorded nocks
-
   lockdown, // use recorded nocks, disables all http calls even when not nocked, doesnt record
 }
 
-Back.setMode = function (mode) {
+Back.setMode = function (mode        ) {
   if (!(mode in Modes)) {
     throw new Error(`Unknown mode: ${mode}`)
   }
@@ -334,11 +359,13 @@ Back.setMode = function (mode) {
   Back.currentMode = mode
   debug('New nock back mode:', Back.currentMode)
 
-  _mode = Modes[mode]
+  _mode = Modes[mode                      ]                    
   _mode.setup()
 }
 
-Back.fixtures = null
-Back.currentMode = null
+Back.fixtures = null                 
+Back.currentMode = ''          
+
+                              
 
-module.exports = Back
+export default Back

package/dist/lib/common.d.ts

@@ -0,0 +1,27 @@
+declare function normalizeRequestOptions(options: Record<string, any>): Record<string, any>;
+declare function isUtf8Representable(buffer: ArrayBuffer | Buffer): boolean;
+declare function normalizeOrigin(url: URL): string;
+declare function stringifyRequest(request: Request, body: string): string;
+declare function isContentEncoded(headers: Record<string, any>): boolean;
+declare function contentEncoding(headers: Headers, encoder: 'gzip' | 'deflate'): boolean;
+declare function isJSONContent(headers: Headers): boolean;
+declare function headersFieldNamesToLowerCase(headers: Record<string, any>, throwOnDuplicate?: boolean): Record<string, any>;
+declare const headersFieldsArrayToLowerCase: (headers: string[]) => string[];
+declare function headersInputToRawArray(headers?: any[] | Map<string, any> | Record<string, any>): any[];
+declare function headersArrayToObject(rawHeaders: any[]): Record<string, any>;
+declare function deleteHeadersField(headers: Record<string, any>, fieldNameToDelete: string): void;
+declare function forEachHeader(rawHeaders: any[], callback: (value: any, fieldName: any, index: number) => void): void;
+declare function percentDecode(str: string): string;
+declare function percentEncode(str: string): string;
+declare function matchStringOrRegexp(target: string | null | undefined, pattern: string | RegExp): boolean;
+declare function formatQueryValue(key: string, value: any, stringFormattingFn?: (s: string) => string): [string, any];
+declare function isStream(obj: any): any;
+declare const dataEqual: (expected: any, actual: any) => boolean;
+declare const setTimeout: (callback: (...args: any[]) => any, ...timerArgs: any[]) => any;
+declare const setImmediate: (callback: (...args: any[]) => any, ...timerArgs: any[]) => any;
+declare function removeAllTimers(): void;
+declare function isPlainObject(value: any): boolean;
+declare const expand: (input: Record<string, any> | null | undefined) => Record<string, any> | null | undefined;
+declare function decompressRequestBody(buffer: ArrayBuffer, contentEncoding: string): ArrayBuffer | NonSharedBuffer;
+declare function convertHeadersToRaw(headers: Headers): string[];
+export { contentEncoding, dataEqual, deleteHeadersField, expand, forEachHeader, formatQueryValue, headersArrayToObject, headersFieldNamesToLowerCase, headersFieldsArrayToLowerCase, headersInputToRawArray, isContentEncoded, isJSONContent, isPlainObject, isStream, isUtf8Representable, matchStringOrRegexp, normalizeOrigin, normalizeRequestOptions, percentDecode, percentEncode, removeAllTimers, setImmediate, setTimeout, stringifyRequest, decompressRequestBody, convertHeadersToRaw, };