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

package/src/core/handlers/handler.ts

@@ -32,8 +32,9 @@ export abstract class Handler {
   /**
    * Release the resources held by this handler.
    *
-   * @note This method is invoked automatically when the network is
-   * disabled (e.g. `server.close()`). Override it in the handlers that
+   * @note This method is invoked automatically when the handler leaves
+   * the network: when the network is disabled (e.g. `server.close()`)
+   * or when a reset removes it (e.g. `server.resetHandlers()`). Override it in the handlers that
    * hold onto anything beyond a single frame, like timers, connections,
    * or event listeners. Returning a promise makes the network await
    * this handler's disposal before it tears itself down.

package/src/graphql/graphql-subscription.ts

@@ -585,24 +585,32 @@ export class GraphQLSubscriptionTransportHandler extends GraphQLWebSocketHandler
   }
 
   /**
-   * Drop this transport's subscribers and active subscriptions from the
-   * sessions it participates in. The sessions themselves are left intact:
-   * they are shared with the other transports of the same connection and
-   * own the protocol listeners for as long as the client stays connected.
+   * Remove the given handler from the subscribers of every session
+   * this transport participates in. The handler no longer matches
+   * subscriptions on the connections opened while it was registered.
+   */
+  public unsubscribe(handler: WebSocketHandler): void {
+    for (const connection of connections.values()) {
+      connection.subscribers.delete(handler)
+    }
+  }
+
+  /**
+   * End the active subscriptions of the sessions this transport
+   * participates in. The sessions and their subscribers are left intact:
+   * the handlers that survive the reset keep serving the connections
+   * opened before it, while the removed handlers unsubscribe themselves
+   * on disposal. The sessions own the protocol listeners for as long as
+   * the client stays connected.
    *
    * @note This method is invoked automatically when the handlers
    * controller resets the handlers (e.g. `server.resetHandlers()`).
    */
   public reset(): void {
     for (const connection of connections.values()) {
-      let ownsConnection = false
-
-      for (const [handler, entry] of connection.subscribers) {
-        if (entry.transport === this) {
-          connection.subscribers.delete(handler)
-          ownsConnection = true
-        }
-      }
+      const ownsConnection = Array.from(connection.subscribers.values()).some(
+        (entry) => entry.transport === this,
+      )
 
       // Resetting the handlers detaches the resolvers from their
       // subscriptions, so run their cleanups instead of dropping them.
@@ -935,6 +943,16 @@ export class GraphQLSubscriptionHandler<
     this.isUsed = false
   }
 
+  /**
+   * Stop serving the connections this handler was bound to.
+   * @note This method is invoked automatically when the handler
+   * is removed from the network, either by resetting the handlers
+   * (e.g. `server.resetHandlers()`) or by disabling the network.
+   */
+  public dispose(): void {
+    this.#transport.unsubscribe(this)
+  }
+
   /**
    * @note Individual subscription handlers stay silent. The subscription
    * transport owns the GraphQL-aware logging for the entire connection

package/src/vite/plugin.test.ts

@@ -784,7 +784,7 @@ test('serves only the worker in worker-only mode with an absolute base URL', asy
     server.environments.client.pluginContainer.resolveId('virtual:msw'),
   ).resolves.toBeNull()
   await expect(
-    server.environments.ssr.pluginContainer.resolveId('virtual:msw/options'),
+    server.environments.ssr.pluginContainer.resolveId('virtual:msw'),
   ).resolves.toBeNull()
 })
 

package/src/vite/plugin.ts

@@ -5,7 +5,6 @@ import type { Plugin } from 'vite'
 const WORKER_FILENAME = 'mockServiceWorker.js'
 const WORKER_SCRIPT_PATH = new URL('../mockServiceWorker.js', import.meta.url)
 const VIRTUAL_MODULE_ID = 'virtual:msw'
-const VIRTUAL_OPTIONS_ID = 'virtual:msw/options'
 const RUNTIME_PATH = fileURLToPath(new URL('./runtime.js', import.meta.url))
 
 export interface MswPluginOptions {
@@ -53,33 +52,37 @@ export function msw(options: MswPluginOptions = {}): Plugin {
 
   return {
     name: 'msw',
-    async resolveId(id) {
+    resolveId(id) {
       if (mode === 'worker-only') {
         return
       }
 
-      if (id === VIRTUAL_OPTIONS_ID) {
-        return `\0${VIRTUAL_OPTIONS_ID}`
-      }
-
       if (id === VIRTUAL_MODULE_ID) {
-        return this.resolve(RUNTIME_PATH)
+        return `\0${VIRTUAL_MODULE_ID}`
       }
     },
     load(id) {
-      if (mode === 'worker-only' || id !== `\0${VIRTUAL_OPTIONS_ID}`) {
+      if (mode === 'worker-only' || id !== `\0${VIRTUAL_MODULE_ID}`) {
         return
       }
 
+      // Tools like Vitest import the runtime natively when it's installed
+      // in "node_modules". Provide it with the environment's options from here
+      // so it never has to import a virtual module that only Vite can resolve.
       if (this.environment.config.consumer === 'server') {
-        return `export { defaultNetworkOptions } from 'msw/node'`
+        return `
+import { defaultNetworkOptions } from 'msw/node'
+import { createNetwork } from ${JSON.stringify(RUNTIME_PATH)}
+export const network = await createNetwork(defaultNetworkOptions)
+`
       }
 
       environmentsUsingNetwork.add(this.environment.name)
 
       return `
 import { createDefaultNetworkOptions } from 'msw/browser'
-export const defaultNetworkOptions = createDefaultNetworkOptions(${JSON.stringify(workerUrl)})
+import { createNetwork } from ${JSON.stringify(RUNTIME_PATH)}
+export const network = await createNetwork(createDefaultNetworkOptions(${JSON.stringify(workerUrl)}))
 `
     },
     configResolved(config) {

package/src/vite/runtime.ts

@@ -1,117 +1,117 @@
 /// <reference types="vite/client" />
 
-import {
-  defineNetwork,
-  NetworkReadyState,
-  type NetworkApi,
-} from 'msw/experimental'
-import { defaultNetworkOptions } from 'virtual:msw/options'
+import { defineNetwork, NetworkReadyState } from 'msw/experimental'
 
 const hot = import.meta.hot
 const hotData: { disposeNetwork?: () => Promise<void> } | undefined = hot?.data
 
-// SSR imports can re-evaluate this module before the old HMR listener runs.
-while (hotData?.disposeNetwork) {
-  const disposePrevious = hotData.disposeNetwork
-  await disposePrevious()
+export async function createNetwork(
+  options: Parameters<typeof defineNetwork>[0],
+): Promise<ReturnType<typeof defineNetwork>> {
+  // SSR imports can re-evaluate the network before the old HMR listener runs.
+  while (hotData?.disposeNetwork) {
+    const disposePrevious = hotData.disposeNetwork
+    await disposePrevious()
 
-  if (hotData.disposeNetwork === disposePrevious) {
-    break
+    if (hotData.disposeNetwork === disposePrevious) {
+      break
+    }
   }
-}
 
-export const network: NetworkApi<typeof defaultNetworkOptions.sources> =
-  defineNetwork<typeof defaultNetworkOptions.sources>(defaultNetworkOptions)
+  const network = defineNetwork(options)
 
-if (hot && hotData) {
-  let resumeAfterUpdate = false
-  let retired = false
-  let pendingOperation: Promise<void> | undefined
-  const configure = network.configure
-  const enable = network.enable
-  const disable = network.disable
+  if (hot && hotData) {
+    let resumeAfterUpdate = false
+    let retired = false
+    let pendingOperation: Promise<void> | undefined
+    const configure = network.configure
+    const enable = network.enable
+    const disable = network.disable
 
-  const runOperation = (action: () => void | Promise<void>) => {
-    const result = pendingOperation ? pendingOperation.then(action) : action()
+    const runOperation = (action: () => void | Promise<void>) => {
+      const result = pendingOperation ? pendingOperation.then(action) : action()
 
-    if (result instanceof Promise) {
-      const operation = result.finally(() => {
-        if (pendingOperation === operation) {
-          pendingOperation = undefined
-        }
-      })
-      pendingOperation = operation
+      if (result instanceof Promise) {
+        const operation = result.finally(() => {
+          if (pendingOperation === operation) {
+            pendingOperation = undefined
+          }
+        })
+        pendingOperation = operation
 
-      return operation
+        return operation
+      }
     }
-  }
 
-  const stop = () => {
-    if (network.readyState === NetworkReadyState.ENABLED) {
-      return disable()
+    const stop = () => {
+      if (network.readyState === NetworkReadyState.ENABLED) {
+        return disable()
+      }
     }
-  }
 
-  // An SSR entry may be re-evaluated while this module remains cached.
-  network.configure = (options) => {
-    void runOperation(() => {
-      if (retired) {
-        return
-      }
+    // An SSR entry may be re-evaluated while this module remains cached.
+    network.configure = (options) => {
+      void runOperation(() => {
+        if (retired) {
+          return
+        }
 
-      const stopped = stop()
+        const stopped = stop()
 
-      if (stopped instanceof Promise) {
-        return stopped.then(() => configure(options))
-      }
+        if (stopped instanceof Promise) {
+          return stopped.then(() => configure(options))
+        }
 
-      configure(options)
-    })
-  }
-  network.enable = async () => {
-    await runOperation(() => {
-      if (!retired && network.readyState === NetworkReadyState.DISABLED) {
-        return enable()
-      }
-    })
-  }
-  network.disable = async () => {
-    await runOperation(stop)
-  }
+        configure(options)
+      })
+    }
+    network.enable = async () => {
+      await runOperation(() => {
+        if (!retired && network.readyState === NetworkReadyState.DISABLED) {
+          return enable()
+        }
+      })
+    }
+    network.disable = async () => {
+      await runOperation(stop)
+    }
 
-  const disableNetwork = async () => {
-    await network.disable()
-  }
+    const disableNetwork = async () => {
+      await network.disable()
+    }
 
-  const beforeUpdate = async () => {
-    resumeAfterUpdate = network.readyState === NetworkReadyState.ENABLED
-    await disableNetwork()
-  }
+    const beforeUpdate = async () => {
+      resumeAfterUpdate = network.readyState === NetworkReadyState.ENABLED
+      await disableNetwork()
+    }
 
-  const afterUpdate = async () => {
-    const shouldResume = resumeAfterUpdate
-    resumeAfterUpdate = false
+    const afterUpdate = async () => {
+      const shouldResume = resumeAfterUpdate
+      resumeAfterUpdate = false
 
-    if (shouldResume && network.readyState === NetworkReadyState.DISABLED) {
-      await network.enable()
+      if (shouldResume && network.readyState === NetworkReadyState.DISABLED) {
+        await network.enable()
+      }
     }
-  }
 
-  hot.on('vite:beforeUpdate', beforeUpdate)
-  hot.on('vite:afterUpdate', afterUpdate)
-  hot.on('vite:beforeFullReload', disableNetwork)
+    hot.on('vite:beforeUpdate', beforeUpdate)
+    hot.on('vite:afterUpdate', afterUpdate)
+    hot.on('vite:beforeFullReload', disableNetwork)
+
+    const disposeNetwork = async () => {
+      retired = true
+      resumeAfterUpdate = false
 
-  const disposeNetwork = async () => {
-    retired = true
-    resumeAfterUpdate = false
+      hot.off('vite:beforeUpdate', beforeUpdate)
+      hot.off('vite:afterUpdate', afterUpdate)
+      hot.off('vite:beforeFullReload', disableNetwork)
 
-    hot.off('vite:beforeUpdate', beforeUpdate)
-    hot.off('vite:afterUpdate', afterUpdate)
-    hot.off('vite:beforeFullReload', disableNetwork)
+      await disableNetwork()
+    }
 
-    await disableNetwork()
+    hotData.disposeNetwork = disposeNetwork
+    hot.dispose(disposeNetwork)
   }
 
-  hotData.disposeNetwork = disposeNetwork
-  hot.dispose(disposeNetwork)
+  return network
 }

package/src/vite/tsconfig.build.json

@@ -1,6 +1,6 @@
 {
   "extends": "../../tsconfig.base.json",
-  "include": ["./index.ts", "./plugin.ts", "./runtime.ts", "./options.d.ts"],
+  "include": ["./index.ts", "./plugin.ts", "./runtime.ts"],
   "compilerOptions": {
     "types": ["node"]
   }

package/src/vite/options.d.ts

@@ -1,5 +0,0 @@
-declare module 'virtual:msw/options' {
-  export const defaultNetworkOptions:
-    | typeof import('msw/browser').defaultNetworkOptions
-    | typeof import('msw/node').defaultNetworkOptions
-}