@depup/msw 3.0.0-depup.0 → 3.0.1-depup.0

package/lib/mockServiceWorker.js

@@ -7,7 +7,7 @@
  * - Please do NOT modify this file.
  */
 
-const PACKAGE_VERSION = '3.0.0'
+const PACKAGE_VERSION = '3.0.1'
 const INTEGRITY_CHECKSUM = '5cd5cf8b54c3a90f82960cedcd637772'
 const IS_MOCKED_RESPONSE = Symbol('isMockedResponse')
 

package/lib/node/index.js

@@ -1,4 +1,4 @@
-import { m as devUtils } from "../_chunks/cookie-store.js";
+import { h as devUtils } from "../_chunks/cookie-store.js";
 import { c as HandlersController, s as defineNetwork, t as InterceptorSource } from "../_chunks/interceptor-source.js";
 import { invariant } from "outvariant";
 import { WebSocketInterceptor } from "@mswjs/interceptors/WebSocket";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@depup/msw",
-  "version": "3.0.0-depup.0",
-  "description": "Seamless REST/GraphQL API mocking library for browser and Node.js. (with updated dependencies)",
+  "version": "3.0.1-depup.0",
+  "description": "The industry standard for API mocking in JavaScript. (with updated dependencies)",
   "type": "module",
   "main": "./lib/core/index.js",
   "types": "./lib/core/index.d.ts",
@@ -125,7 +125,7 @@
   "dependencies": {
     "@inquirer/confirm": "^6.3.2",
     "@msw/url": "^0.1.2",
-    "@mswjs/interceptors": "^0.45.5",
+    "@mswjs/interceptors": "^0.45.6",
     "cookie": "^2.0.1",
     "headers-polyfill": "^5.0.1",
     "is-node-process": "^1.2.0",
@@ -167,7 +167,7 @@
     "json-bigint": "^1.0.0",
     "knip": "^6.34.0",
     "lint-staged": "^17.1.1",
-    "msw": "^3.0.0",
+    "msw": "^3.0.1",
     "oxlint": "^1.75.0",
     "page-with": "^0.6.1",
     "prettier": "^3.9.6",
@@ -238,8 +238,8 @@
     },
     "depsUpdated": 2,
     "originalPackage": "msw",
-    "originalVersion": "3.0.0",
-    "processedAt": "2026-09-28T16:11:25.377Z",
+    "originalVersion": "3.0.1",
+    "processedAt": "2026-09-30T16:13:04.601Z",
     "smokeTest": "passed"
   }
 }

package/src/core/experimental/frames/http-frame.test.ts

@@ -1,3 +1,4 @@
+import { FetchRequest } from '@mswjs/interceptors'
 import { http } from '#http/http'
 import { graphql } from '../../../graphql'
 import { ws } from '../../../ws'
@@ -169,6 +170,54 @@ test('resolves a non-matching request', async () => {
   ])
 })
 
+/**
+ * @todo Revisit the `http.all()` handler below once `http.connect()`
+ * is supported: a matching CONNECT handler must take precedence.
+ */
+test('passes through an unhandled CONNECT request without applying the unhandled frame strategy', async () => {
+  class HttpFrame extends HttpNetworkFrame {
+    respondWith = vi.fn()
+    passthrough = vi.fn()
+    errorWith = vi.fn()
+  }
+
+  const frame = new HttpFrame({
+    request: new FetchRequest('http://localhost/127.0.0.1:443', {
+      method: 'CONNECT',
+    }),
+  })
+  const { events } = spyOnNetworkFrame(frame)
+  const unhandledFrameCallback = vi.fn()
+
+  const matches = await frame.resolve(
+    [
+      http.all('*', () => {
+        return new Response(null, { status: 204 })
+      }),
+    ],
+    unhandledFrameCallback,
+    { quiet: true },
+  )
+
+  expect.soft(matches).toBe(null)
+  expect.soft(frame.passthrough).toHaveBeenCalledOnce()
+  expect.soft(frame.respondWith).not.toHaveBeenCalled()
+  expect.soft(frame.errorWith).not.toHaveBeenCalled()
+  expect.soft(unhandledFrameCallback).not.toHaveBeenCalled()
+  expect.soft(events).toEqual([
+    expect.objectContaining({
+      type: 'request:start',
+      requestId: frame.data.id,
+      request: frame.data.request,
+    }),
+    expect.objectContaining({
+      type: 'request:end',
+      requestId: frame.data.id,
+      request: frame.data.request,
+    }),
+  ])
+})
+
 test('resolves a matched passthrough', async () => {
   class HttpFrame extends HttpNetworkFrame {
     respondWith = vi.fn()

package/src/core/experimental/frames/http-frame.ts

@@ -6,6 +6,7 @@ import {
   type NetworkFrameResolutionContext,
 } from './network-frame'
 import { toPublicUrl } from '../../utils/request/to-public-url'
+import { isStringEqual } from '../../utils/internal/is-string-equal'
 import { executeHandlers } from '../../utils/execute-handlers'
 import { storeResponseCookies } from '../../utils/request/store-response-cookies'
 import { shouldBypassRequest } from '../request-utils'
@@ -191,6 +192,24 @@ export abstract class HttpNetworkFrame extends NetworkFrame<
 
     // No matching handlers.
     if (lookupResult == null) {
+      /**
+       * @note Unhandled CONNECT requests establish a tunnel through a proxy.
+       * They are transport, not the request the developer cares about, so
+       * they pass through silently regardless of the unhandled frame strategy.
+       * The request sent through the tunnel gets its own resolution.
+       */
+      if (isStringEqual(request.method, 'CONNECT')) {
+        this.events.emit(
+          new RequestEvent('request:end', {
+            requestId,
+            request,
+          }),
+        )
+
+        this.passthrough()
+        return null
+      }
+
       this.events.emit(
         new RequestEvent('request:unhandled', {
           requestId,

package/src/http/http-handler.test.ts

@@ -1,5 +1,5 @@
 // @vitest-environment jsdom
-import { createRequestId } from '@mswjs/interceptors'
+import { createRequestId, FetchRequest } from '@mswjs/interceptors'
 import type { HttpRequestResolverExtras } from './http-handler'
 import { HttpHandler } from './http-handler'
 import { HttpResponse } from './index'
@@ -70,6 +70,24 @@ describe('parse', () => {
 })
 
 describe('predicate', () => {
+  /**
+   * @todo Decide whether `http.all()` matches CONNECT requests
+   * once `http.connect()` is supported.
+   */
+  test('returns false given a CONNECT request', async () => {
+    const handler = new HttpHandler(/.+/, '*', resolver)
+    const request = new FetchRequest('http://localhost/127.0.0.1:443', {
+      method: 'CONNECT',
+    })
+
+    await expect(
+      handler.predicate({
+        request,
+        parsedResult: await handler.parse({ request }),
+      }),
+    ).resolves.toBe(false)
+  })
+
   test('returns true given a matching request', async () => {
     const handler = new HttpHandler('POST', '/login', resolver)
     const request = new Request(new URL('/login', location.href), {

package/src/http/http-handler.ts

@@ -122,6 +122,19 @@ export class HttpHandler extends RequestHandler<
     request: Request
     resolutionContext?: ResponseResolutionContext
   }) {
+    /**
+     * @note CONNECT requests target an authority ("host:port"), not a URL.
+     * HTTP handlers never match them.
+     * @todo Match the authority against the handler path once
+     * `http.connect()` is supported instead of bailing out.
+     */
+    if (isStringEqual(args.request.method, 'CONNECT')) {
+      return {
+        match: { matches: false, params: {} },
+        cookies: {},
+      }
+    }
+
     const url = new URL(args.request.url)
     const cookies = getAllRequestCookies(args.request)
 

package/src/vite/plugin.test.ts

@@ -454,6 +454,9 @@ document.querySelector('output').textContent = String(network.readyState)
 let completedUpdates = 0
 
 if (import.meta.hot) {
+  import.meta.hot.on('vite:beforeUpdate', () => {
+    document.body.dataset.disabledBeforeUpdate = String(network.readyState === 0)
+  })
   import.meta.hot.on('vite:afterUpdate', () => {
     document.body.dataset.completedUpdates = String(++completedUpdates)
   })
@@ -519,18 +522,33 @@ document.querySelector('button').onclick = async () => {
   await page.getByRole('button', { name: 'Enable' }).click()
 
   await expect.poll(() => page.locator('output').textContent()).toBe('mocked')
+  await page.evaluate(() => {
+    delete document.body.dataset.disabledBeforeUpdate
+  })
   server.environments.client.hot.send({ type: 'update', updates: [] })
 
   await expect
     .poll(() => page.locator('body').getAttribute('data-completed-updates'))
     .toBe('2')
   await expect(
-    page.evaluate(async () => {
-      const response = await fetch('/resource')
-
-      return response.text()
-    }),
-  ).resolves.toBe('mocked')
+    page.locator('body').getAttribute('data-disabled-before-update'),
+  ).resolves.toBe('true')
+  /**
+   * @note The runtime re-enables the network after the update asynchronously:
+   * the worker has to be re-activated before it can respond with mocks.
+   * Until then, requests reach the dev server. Poll for the mocked response.
+   */
+  await expect
+    .poll(
+      () =>
+        page.evaluate(async () => {
+          const response = await fetch('/resource')
+
+          return response.text()
+        }),
+      { timeout: 10_000 },
+    )
+    .toBe('mocked')
   await expect(
     page.evaluate(async () => {
       const registrations = await navigator.serviceWorker.getRegistrations()