@depup/mswjs__interceptors 0.41.3-depup.0

package/src/utils/createProxy.test.ts

@@ -0,0 +1,164 @@
+import { vi, it, expect } from 'vitest'
+import { createProxy } from './createProxy'
+
+it('does not interfere with default constructors', () => {
+  const ProxyClass = createProxy(
+    class {
+      constructor(public name: string) {}
+    },
+    {}
+  )
+
+  const instance = new ProxyClass('John')
+  expect(instance.name).toBe('John')
+})
+
+it('does not interfere with default getters', () => {
+  const proxy = createProxy({ foo: 'initial' }, {})
+  expect(proxy.foo).toBe('initial')
+})
+
+it('does not interfere with default setters', () => {
+  const proxy = createProxy({ foo: 'initial' }, {})
+  proxy.foo = 'next'
+
+  expect(proxy.foo).toBe('next')
+})
+
+it('does not interfere with default methods', () => {
+  const proxy = createProxy({ getValue: () => 'initial' }, {})
+  expect(proxy.getValue()).toBe('initial')
+})
+
+it('does not interfere with existing descriptors', () => {
+  const target = {} as { foo: string; bar: number }
+  let internalBar = 0
+
+  Object.defineProperties(target, {
+    foo: {
+      get: () => 'initial',
+    },
+    bar: {
+      set: (value) => {
+        internalBar = value + 10
+      },
+    },
+  })
+
+  const proxy = createProxy(target, {
+    getProperty(data, next) {
+      return next()
+    },
+  })
+  expect(proxy.foo).toBe('initial')
+
+  proxy.bar = 5
+  expect(proxy.bar).toBeUndefined()
+  expect(internalBar).toBe(15)
+})
+
+it('infer prototype descriptors', () => {
+  class Child {
+    ok: boolean
+
+    set status(nextStatus: number) {
+      this.ok = nextStatus >= 200 && nextStatus < 300
+    }
+  }
+
+  Object.defineProperties(Child.prototype, {
+    status: { enumerable: true },
+  })
+
+  const scope = {} as { child: typeof Child }
+
+  Object.defineProperty(scope, 'child', {
+    enumerable: true,
+    value: Child,
+  })
+
+  const ProxyClass = createProxy(scope.child, {})
+  const instance = new ProxyClass()
+
+  instance.status = 201
+  expect(instance.ok).toBe(true)
+})
+
+it('spies on the constructor', () => {
+  const OriginalClass = class {
+    constructor(public name: string, public age: number) {}
+  }
+
+  const constructorCall = vi.fn<
+    (
+      args: ConstructorParameters<typeof OriginalClass>,
+      next: () => typeof OriginalClass
+    ) => typeof OriginalClass
+  >((args, next) => next())
+
+  const ProxyClass = createProxy(OriginalClass, {
+    constructorCall,
+  })
+
+  new ProxyClass('John', 32)
+
+  expect(constructorCall).toHaveBeenCalledTimes(1)
+  expect(constructorCall).toHaveBeenCalledWith(
+    ['John', 32],
+    expect.any(Function)
+  )
+})
+
+it('spies on property getters', () => {
+  const getProperty = vi.fn((args, next) => next())
+  const proxy = createProxy({ foo: 'initial' }, { getProperty })
+
+  proxy.foo
+
+  expect(getProperty).toHaveBeenCalledTimes(1)
+  expect(getProperty).toHaveBeenCalledWith(['foo', proxy], expect.any(Function))
+})
+
+it('spies on property setters', () => {
+  const setProperty = vi.fn((args, next) => next())
+  const proxy = createProxy({ foo: 'initial' }, { setProperty })
+
+  proxy.foo = 'next'
+
+  expect(setProperty).toHaveBeenCalledTimes(1)
+  expect(setProperty).toHaveBeenCalledWith(
+    ['foo', 'next'],
+    expect.any(Function)
+  )
+})
+
+it('spies on method calls', () => {
+  const methodCall = vi.fn((args, next) => next())
+  const proxy = createProxy(
+    {
+      greet: (name: string) => `hello ${name}`,
+    },
+    { methodCall }
+  )
+
+  proxy.greet('Clair')
+
+  expect(methodCall).toHaveBeenCalledTimes(1)
+  expect(methodCall).toHaveBeenCalledWith(
+    ['greet', ['Clair']],
+    expect.any(Function)
+  )
+})
+
+it('proxies properties on the prototype level', () => {
+  const method = vi.fn()
+  const prototype = { method }
+
+  const proxy = createProxy(Object.create(prototype), {})
+  const proxyMethod = vi.fn()
+  proxy.method = proxyMethod
+
+  prototype.method()
+  expect(method).toHaveBeenCalledTimes(0)
+  expect(proxyMethod).toHaveBeenCalledTimes(1)
+})

package/src/utils/createProxy.ts

@@ -0,0 +1,104 @@
+import { findPropertySource } from './findPropertySource'
+
+export interface ProxyOptions<Target extends Record<string, any>> {
+  constructorCall?(args: Array<unknown>, next: NextFunction<Target>): Target
+
+  methodCall?<F extends keyof Target>(
+    this: Target,
+    data: [methodName: F, args: Array<unknown>],
+    next: NextFunction<void>
+  ): void
+
+  setProperty?(
+    data: [propertyName: string | symbol, nextValue: unknown],
+    next: NextFunction<boolean>
+  ): boolean
+
+  getProperty?(
+    data: [propertyName: string | symbol, receiver: Target],
+    next: NextFunction<void>
+  ): void
+}
+
+export type NextFunction<ReturnType> = () => ReturnType
+
+export function createProxy<Target extends object>(
+  target: Target,
+  options: ProxyOptions<Target>
+): Target {
+  const proxy = new Proxy(target, optionsToProxyHandler(options))
+
+  return proxy
+}
+
+function optionsToProxyHandler<T extends Record<string, any>>(
+  options: ProxyOptions<T>
+): ProxyHandler<T> {
+  const { constructorCall, methodCall, getProperty, setProperty } = options
+  const handler: ProxyHandler<T> = {}
+
+  if (typeof constructorCall !== 'undefined') {
+    handler.construct = function (target, args, newTarget) {
+      const next = Reflect.construct.bind(null, target as any, args, newTarget)
+      return constructorCall.call(newTarget, args, next)
+    }
+  }
+
+  handler.set = function (target, propertyName, nextValue) {
+    const next = () => {
+      const propertySource = findPropertySource(target, propertyName) || target
+      const ownDescriptors = Reflect.getOwnPropertyDescriptor(
+        propertySource,
+        propertyName
+      )
+
+      // Respect any custom setters present for this property.
+      if (typeof ownDescriptors?.set !== 'undefined') {
+        ownDescriptors.set.apply(target, [nextValue])
+        return true
+      }
+
+      // Otherwise, set the property on the source.
+      return Reflect.defineProperty(propertySource, propertyName, {
+        writable: true,
+        enumerable: true,
+        configurable: true,
+        value: nextValue,
+      })
+    }
+
+    if (typeof setProperty !== 'undefined') {
+      return setProperty.call(target, [propertyName, nextValue], next)
+    }
+
+    return next()
+  }
+
+  handler.get = function (target, propertyName, receiver) {
+    /**
+     * @note Using `Reflect.get()` here causes "TypeError: Illegal invocation".
+     */
+    const next = () => target[propertyName as any]
+
+    const value =
+      typeof getProperty !== 'undefined'
+        ? getProperty.call(target, [propertyName, receiver], next)
+        : next()
+
+    if (typeof value === 'function') {
+      return (...args: Array<any>) => {
+        const next = value.bind(target, ...args)
+
+        if (typeof methodCall !== 'undefined') {
+          return methodCall.call(target, [propertyName as any, args], next)
+        }
+
+        return next()
+      }
+    }
+
+    return value
+  }
+
+  return handler
+}

package/src/utils/emitAsync.ts

@@ -0,0 +1,25 @@
+import { Emitter, EventMap } from 'strict-event-emitter'
+
+/**
+ * Emits an event on the given emitter but executes
+ * the listeners sequentially. This accounts for asynchronous
+ * listeners (e.g. those having "sleep" and handling the request).
+ */
+export async function emitAsync<
+  Events extends EventMap,
+  EventName extends keyof Events
+>(
+  emitter: Emitter<Events>,
+  eventName: EventName,
+  ...data: Events[EventName]
+): Promise<void> {
+  const listeners = emitter.listeners(eventName)
+
+  if (listeners.length === 0) {
+    return
+  }
+
+  for (const listener of listeners) {
+    await listener.apply(emitter, data)
+  }
+}

package/src/utils/fetchUtils.ts

@@ -0,0 +1,119 @@
+import { canParseUrl } from './canParseUrl'
+import { getValueBySymbol } from './getValueBySymbol'
+
+export interface FetchResponseInit extends ResponseInit {
+  url?: string
+}
+
+interface UndiciFetchInternalState {
+  aborted: boolean
+  rangeRequested: boolean
+  timingAllowPassed: boolean
+  requestIncludesCredentials: boolean
+  type: ResponseType
+  status: number
+  statusText: string
+  timingInfo: unknown
+  cacheState: unknown
+  headersList: Record<symbol, Map<string, unknown>>
+  urlList: Array<URL>
+  body?: {
+    stream: ReadableStream
+    source: unknown
+    length: number
+  }
+}
+
+export class FetchResponse extends Response {
+  /**
+   * Response status codes for responses that cannot have body.
+   * @see https://fetch.spec.whatwg.org/#statuses
+   */
+  static readonly STATUS_CODES_WITHOUT_BODY = [101, 103, 204, 205, 304]
+
+  static readonly STATUS_CODES_WITH_REDIRECT = [301, 302, 303, 307, 308]
+
+  static isConfigurableStatusCode(status: number): boolean {
+    return status >= 200 && status <= 599
+  }
+
+  static isRedirectResponse(status: number): boolean {
+    return FetchResponse.STATUS_CODES_WITH_REDIRECT.includes(status)
+  }
+
+  /**
+   * Returns a boolean indicating whether the given response status
+   * code represents a response that can have a body.
+   */
+  static isResponseWithBody(status: number): boolean {
+    return !FetchResponse.STATUS_CODES_WITHOUT_BODY.includes(status)
+  }
+
+  static setUrl(url: string | undefined, response: Response): void {
+    if (!url || url === 'about:' || !canParseUrl(url)) {
+      return
+    }
+
+    const state = getValueBySymbol<UndiciFetchInternalState>('state', response)
+
+    if (state) {
+      // In Undici, push the URL to the internal list of URLs.
+      // This will respect the `response.url` getter logic correctly.
+      state.urlList.push(new URL(url))
+    } else {
+      // In other libraries, redefine the `url` property directly.
+      Object.defineProperty(response, 'url', {
+        value: url,
+        enumerable: true,
+        configurable: true,
+        writable: false,
+      })
+    }
+  }
+
+  /**
+   * Parses the given raw HTTP headers into a Fetch API `Headers` instance.
+   */
+  static parseRawHeaders(rawHeaders: Array<string>): Headers {
+    const headers = new Headers()
+    for (let line = 0; line < rawHeaders.length; line += 2) {
+      headers.append(rawHeaders[line], rawHeaders[line + 1])
+    }
+    return headers
+  }
+
+  constructor(body?: BodyInit | null, init: FetchResponseInit = {}) {
+    const status = init.status ?? 200
+    const safeStatus = FetchResponse.isConfigurableStatusCode(status)
+      ? status
+      : 200
+    const finalBody = FetchResponse.isResponseWithBody(status) ? body : null
+
+    super(finalBody, {
+      status: safeStatus,
+      statusText: init.statusText,
+      headers: init.headers,
+    })
+
+    if (status !== safeStatus) {
+      /**
+       * @note Undici keeps an internal "Symbol(state)" that holds
+       * the actual value of response status. Update that in Node.js.
+       */
+      const state = getValueBySymbol<UndiciFetchInternalState>('state', this)
+
+      if (state) {
+        state.status = status
+      } else {
+        Object.defineProperty(this, 'status', {
+          value: status,
+          enumerable: true,
+          configurable: true,
+          writable: false,
+        })
+      }
+    }
+
+    FetchResponse.setUrl(init.url, this)
+  }
+}

package/src/utils/findPropertySource.test.ts

@@ -0,0 +1,27 @@
+import { it, expect } from 'vitest'
+import { findPropertySource } from './findPropertySource'
+
+it('returns the source for objects without prototypes', () => {
+  const obj = Object.create(null)
+  obj.test = undefined
+  const source = findPropertySource(obj, 'test')
+  expect(source).toBe(obj)
+})
+
+it('returns the source for objects with prototypes', () => {
+  const prototype = Object.create(null)
+  prototype.test = undefined
+
+  const obj = Object.create(prototype)
+
+  const source = findPropertySource(obj, 'test')
+  expect(source).toBe(prototype)
+})
+
+it('returns null if the prototype chain does not contain the property', () => {
+  const prototype = Object.create(null)
+  const obj = Object.create(prototype)
+
+  const source = findPropertySource(obj, 'test')
+  expect(source).toBeNull()
+})

package/src/utils/findPropertySource.ts

@@ -0,0 +1,20 @@
+/**
+ * Returns the source object of the given property on the target object
+ * (the target itself, any parent in its prototype, or null).
+ */
+export function findPropertySource(
+  target: object,
+  propertyName: string | symbol
+): object | null {
+  if (!(propertyName in target)) {
+    return null
+  }
+
+  const hasProperty = Object.prototype.hasOwnProperty.call(target, propertyName)
+  if (hasProperty) {
+    return target
+  }
+
+  const prototype = Reflect.getPrototypeOf(target)
+  return prototype ? findPropertySource(prototype, propertyName) : null
+}

package/src/utils/getCleanUrl.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest'
+import { getCleanUrl } from './getCleanUrl'
+
+describe('getCleanUrl', () => {
+  describe('given a URL without query parameters', () => {
+    it('should return url href as-is', () => {
+      const url = new URL('https://github.com')
+      expect(getCleanUrl(url)).toEqual('https://github.com/')
+    })
+  })
+
+  describe('given a URL with query parameters', () => {
+    it('should return url without parameters', () => {
+      const url = new URL('https://github.com/mswjs/?userId=abc-123')
+      expect(getCleanUrl(url)).toEqual('https://github.com/mswjs/')
+    })
+  })
+
+  describe('given a URL with a hash', () => {
+    it('should return a url without hash', () => {
+      const url = new URL('https://github.com/mswjs/#hello-world')
+      expect(getCleanUrl(url)).toEqual('https://github.com/mswjs/')
+    })
+  })
+
+  describe('given an absolute URL ', () => {
+    it('should return a clean relative URL', () => {
+      const url = new URL('/login?query=value', 'https://github.com')
+      expect(getCleanUrl(url, false)).toEqual('/login')
+    })
+  })
+})

package/src/utils/getCleanUrl.ts

@@ -0,0 +1,6 @@
+/**
+ * Removes query parameters and hashes from a given URL.
+ */
+export function getCleanUrl(url: URL, isAbsolute: boolean = true): string {
+  return [isAbsolute && url.origin, url.pathname].filter(Boolean).join('')
+}

package/src/utils/getUrlByRequestOptions.test.ts

@@ -0,0 +1,163 @@
+import { it, expect } from 'vitest'
+import { Agent as HttpAgent } from 'http'
+import { RequestOptions, Agent as HttpsAgent } from 'https'
+import { getUrlByRequestOptions } from './getUrlByRequestOptions'
+
+it('returns a URL based on the basic RequestOptions', () => {
+  expect(
+    getUrlByRequestOptions({
+      protocol: 'https:',
+      host: '127.0.0.1',
+      path: '/resource',
+    }).href
+  ).toBe('https://127.0.0.1/resource')
+})
+
+it('inherits protocol and port from http.Agent, if set', () => {
+  expect(
+    getUrlByRequestOptions({
+      host: '127.0.0.1',
+      path: '/',
+      agent: new HttpAgent(),
+    }).href
+  ).toBe('http://127.0.0.1/')
+})
+
+it('inherits protocol and port from https.Agent, if set', () => {
+  expect(
+    getUrlByRequestOptions({
+      host: '127.0.0.1',
+      path: '/',
+      agent: new HttpsAgent({
+        port: 3080,
+      }),
+    }).href
+  ).toBe('https://127.0.0.1:3080/')
+})
+
+it('resolves protocol to "http" given no explicit protocol and no certificate', () => {
+  expect(
+    getUrlByRequestOptions({
+      host: '127.0.0.1',
+      path: '/',
+    }).href
+  ).toBe('http://127.0.0.1/')
+})
+
+it('resolves protocol to "https" given no explicit protocol, but certificate', () => {
+  expect(
+    getUrlByRequestOptions({
+      host: '127.0.0.1',
+      path: '/secure',
+      cert: '<!-- SSL certificate -->',
+    }).href
+  ).toBe('https://127.0.0.1/secure')
+})
+
+it('resolves protocol to "https" given no explicit protocol, but port is 443', () => {
+  expect(
+    getUrlByRequestOptions({
+      host: '127.0.0.1',
+      port: 443,
+      path: '/resource',
+    }).href
+  ).toBe('https://127.0.0.1/resource')
+})
+
+it('resolves protocol to "https" given no explicit protocol, but agent port is 443', () => {
+  expect(
+    getUrlByRequestOptions({
+      host: '127.0.0.1',
+      agent: new HttpsAgent({
+        port: 443,
+      }),
+      path: '/resource',
+    }).href
+  ).toBe('https://127.0.0.1/resource')
+})
+
+it('respects explicitly provided port', () => {
+  expect(
+    getUrlByRequestOptions({
+      protocol: 'http:',
+      host: '127.0.0.1',
+      port: 4002,
+      path: '/',
+    }).href
+  ).toBe('http://127.0.0.1:4002/')
+})
+
+it('inherits "username" and "password"', () => {
+  const url = getUrlByRequestOptions({
+    protocol: 'https:',
+    host: '127.0.0.1',
+    path: '/user',
+    auth: 'admin:abc-123',
+  })
+
+  expect(url).toBeInstanceOf(URL)
+  expect(url).toHaveProperty('username', 'admin')
+  expect(url).toHaveProperty('password', 'abc-123')
+  expect(url).toHaveProperty('href', 'https://admin:abc-123@127.0.0.1/user')
+})
+
+it('resolves hostname to localhost if none provided', () => {
+  expect(getUrlByRequestOptions({}).hostname).toBe('localhost')
+})
+
+it('resolves host to localhost if none provided', () => {
+  expect(getUrlByRequestOptions({}).host).toBe('localhost')
+})
+
+it('supports "hostname" and "port"', () => {
+  const options: RequestOptions = {
+    protocol: 'https:',
+    hostname: '127.0.0.1',
+    port: 1234,
+    path: '/resource',
+  }
+
+  expect(getUrlByRequestOptions(options).href).toBe(
+    'https://127.0.0.1:1234/resource'
+  )
+})
+
+it('use "hostname" if both "hostname" and "host" are specified', () => {
+  const options: RequestOptions = {
+    protocol: 'https:',
+    host: 'host',
+    hostname: 'hostname',
+    path: '/resource',
+  }
+
+  expect(getUrlByRequestOptions(options).href).toBe(
+    'https://hostname/resource'
+  )
+})
+
+it('parses "host" in IPv6', () => {
+  expect(
+    getUrlByRequestOptions({
+      host: '::1',
+      path: '/resource',
+    }).href
+  ).toBe('http://[::1]/resource')
+
+  expect(
+    getUrlByRequestOptions({
+      host: '[::1]',
+      path: '/resource',
+    }).href
+  ).toBe('http://[::1]/resource')
+
+})
+
+it('parses "host" and "port" in IPv6', () => {
+  expect(
+    getUrlByRequestOptions({
+      host: '::1',
+      port: 3001,
+      path: '/resource',
+    }).href
+  ).toBe('http://[::1]:3001/resource')
+})