diff --git a/examples/with-apollo/index.html b/examples/with-apollo/index.html
new file mode 100644
index 0000000..930ffa7
--- /dev/null
+++ b/examples/with-apollo/index.html
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+ Apollo + MSW
+
+
+
+
+
+
diff --git a/examples/with-apollo/package.json b/examples/with-apollo/package.json
new file mode 100644
index 0000000..f7a3ca8
--- /dev/null
+++ b/examples/with-apollo/package.json
@@ -0,0 +1,40 @@
+{
+ "name": "with-apollo",
+ "type": "module",
+ "version": "0.0.0",
+ "description": "",
+ "scripts": {
+ "dev": "vite",
+ "build": "tsc -b && vite build"
+ },
+ "dependencies": {
+ "@apollo/client": "^3.11.10",
+ "@apollo/server": "^4.11.2",
+ "@graphql-tools/schema": "^10.0.8",
+ "@types/cors": "^2.8.17",
+ "@types/express": "^5.0.0",
+ "@types/react": "^18.0.35",
+ "@types/react-dom": "^18.0.11",
+ "@types/ws": "^8.5.13",
+ "cors": "^2.8.5",
+ "express": "^4.21.1",
+ "graphql": "^16.9.0",
+ "graphql-subscriptions": "^3.0.0",
+ "graphql-ws": "^5.16.0",
+ "msw": "2.6.4",
+ "react": "^18.2.0",
+ "react-dom": "^18.2.0",
+ "ws": "^8.18.0"
+ },
+ "devDependencies": {
+ "@types/node": "^22.9.0",
+ "@vitejs/plugin-react": "^4.3.3",
+ "typescript": "^5.6.3",
+ "vite": "^5.4.11"
+ },
+ "msw": {
+ "workerDirectory": [
+ "public"
+ ]
+ }
+}
\ No newline at end of file
diff --git a/examples/with-apollo/public/mockServiceWorker.js b/examples/with-apollo/public/mockServiceWorker.js
new file mode 100644
index 0000000..8241ef8
--- /dev/null
+++ b/examples/with-apollo/public/mockServiceWorker.js
@@ -0,0 +1,295 @@
+/* eslint-disable */
+/* tslint:disable */
+
+/**
+ * Mock Service Worker.
+ * @see https://github.com/mswjs/msw
+ * - Please do NOT modify this file.
+ * - Please do NOT serve this file on production.
+ */
+
+const PACKAGE_VERSION = '2.6.4'
+const INTEGRITY_CHECKSUM = 'ca7800994cc8bfb5eb961e037c877074'
+const IS_MOCKED_RESPONSE = Symbol('isMockedResponse')
+const activeClientIds = new Set()
+
+self.addEventListener('install', function () {
+ self.skipWaiting()
+})
+
+self.addEventListener('activate', function (event) {
+ event.waitUntil(self.clients.claim())
+})
+
+self.addEventListener('message', async function (event) {
+ const clientId = event.source.id
+
+ if (!clientId || !self.clients) {
+ return
+ }
+
+ const client = await self.clients.get(clientId)
+
+ if (!client) {
+ return
+ }
+
+ const allClients = await self.clients.matchAll({
+ type: 'window',
+ })
+
+ switch (event.data) {
+ case 'KEEPALIVE_REQUEST': {
+ sendToClient(client, {
+ type: 'KEEPALIVE_RESPONSE',
+ })
+ break
+ }
+
+ case 'INTEGRITY_CHECK_REQUEST': {
+ sendToClient(client, {
+ type: 'INTEGRITY_CHECK_RESPONSE',
+ payload: {
+ packageVersion: PACKAGE_VERSION,
+ checksum: INTEGRITY_CHECKSUM,
+ },
+ })
+ break
+ }
+
+ case 'MOCK_ACTIVATE': {
+ activeClientIds.add(clientId)
+
+ sendToClient(client, {
+ type: 'MOCKING_ENABLED',
+ payload: {
+ client: {
+ id: client.id,
+ frameType: client.frameType,
+ },
+ },
+ })
+ break
+ }
+
+ case 'MOCK_DEACTIVATE': {
+ activeClientIds.delete(clientId)
+ break
+ }
+
+ case 'CLIENT_CLOSED': {
+ activeClientIds.delete(clientId)
+
+ const remainingClients = allClients.filter((client) => {
+ return client.id !== clientId
+ })
+
+ // Unregister itself when there are no more clients
+ if (remainingClients.length === 0) {
+ self.registration.unregister()
+ }
+
+ break
+ }
+ }
+})
+
+self.addEventListener('fetch', function (event) {
+ const { request } = event
+
+ // Bypass navigation requests.
+ if (request.mode === 'navigate') {
+ return
+ }
+
+ // Opening the DevTools triggers the "only-if-cached" request
+ // that cannot be handled by the worker. Bypass such requests.
+ if (request.cache === 'only-if-cached' && request.mode !== 'same-origin') {
+ return
+ }
+
+ // Bypass all requests when there are no active clients.
+ // Prevents the self-unregistered worked from handling requests
+ // after it's been deleted (still remains active until the next reload).
+ if (activeClientIds.size === 0) {
+ return
+ }
+
+ // Generate unique request ID.
+ const requestId = crypto.randomUUID()
+ event.respondWith(handleRequest(event, requestId))
+})
+
+async function handleRequest(event, requestId) {
+ const client = await resolveMainClient(event)
+ const response = await getResponse(event, client, requestId)
+
+ // Send back the response clone for the "response:*" life-cycle events.
+ // Ensure MSW is active and ready to handle the message, otherwise
+ // this message will pend indefinitely.
+ if (client && activeClientIds.has(client.id)) {
+ ;(async function () {
+ const responseClone = response.clone()
+
+ sendToClient(
+ client,
+ {
+ type: 'RESPONSE',
+ payload: {
+ requestId,
+ isMockedResponse: IS_MOCKED_RESPONSE in response,
+ type: responseClone.type,
+ status: responseClone.status,
+ statusText: responseClone.statusText,
+ body: responseClone.body,
+ headers: Object.fromEntries(responseClone.headers.entries()),
+ },
+ },
+ [responseClone.body],
+ )
+ })()
+ }
+
+ return response
+}
+
+// Resolve the main client for the given event.
+// Client that issues a request doesn't necessarily equal the client
+// that registered the worker. It's with the latter the worker should
+// communicate with during the response resolving phase.
+async function resolveMainClient(event) {
+ const client = await self.clients.get(event.clientId)
+
+ if (activeClientIds.has(event.clientId)) {
+ return client
+ }
+
+ if (client?.frameType === 'top-level') {
+ return client
+ }
+
+ const allClients = await self.clients.matchAll({
+ type: 'window',
+ })
+
+ return allClients
+ .filter((client) => {
+ // Get only those clients that are currently visible.
+ return client.visibilityState === 'visible'
+ })
+ .find((client) => {
+ // Find the client ID that's recorded in the
+ // set of clients that have registered the worker.
+ return activeClientIds.has(client.id)
+ })
+}
+
+async function getResponse(event, client, requestId) {
+ const { request } = event
+
+ // Clone the request because it might've been already used
+ // (i.e. its body has been read and sent to the client).
+ const requestClone = request.clone()
+
+ function passthrough() {
+ // Cast the request headers to a new Headers instance
+ // so the headers can be manipulated with.
+ const headers = new Headers(requestClone.headers)
+
+ // Remove the "accept" header value that marked this request as passthrough.
+ // This prevents request alteration and also keeps it compliant with the
+ // user-defined CORS policies.
+ headers.delete('accept', 'msw/passthrough')
+
+ return fetch(requestClone, { headers })
+ }
+
+ // Bypass mocking when the client is not active.
+ if (!client) {
+ return passthrough()
+ }
+
+ // Bypass initial page load requests (i.e. static assets).
+ // The absence of the immediate/parent client in the map of the active clients
+ // means that MSW hasn't dispatched the "MOCK_ACTIVATE" event yet
+ // and is not ready to handle requests.
+ if (!activeClientIds.has(client.id)) {
+ return passthrough()
+ }
+
+ // Notify the client that a request has been intercepted.
+ const requestBuffer = await request.arrayBuffer()
+ const clientMessage = await sendToClient(
+ client,
+ {
+ type: 'REQUEST',
+ payload: {
+ id: requestId,
+ url: request.url,
+ mode: request.mode,
+ method: request.method,
+ headers: Object.fromEntries(request.headers.entries()),
+ cache: request.cache,
+ credentials: request.credentials,
+ destination: request.destination,
+ integrity: request.integrity,
+ redirect: request.redirect,
+ referrer: request.referrer,
+ referrerPolicy: request.referrerPolicy,
+ body: requestBuffer,
+ keepalive: request.keepalive,
+ },
+ },
+ [requestBuffer],
+ )
+
+ switch (clientMessage.type) {
+ case 'MOCK_RESPONSE': {
+ return respondWithMock(clientMessage.data)
+ }
+
+ case 'PASSTHROUGH': {
+ return passthrough()
+ }
+ }
+
+ return passthrough()
+}
+
+function sendToClient(client, message, transferrables = []) {
+ return new Promise((resolve, reject) => {
+ const channel = new MessageChannel()
+
+ channel.port1.onmessage = (event) => {
+ if (event.data && event.data.error) {
+ return reject(event.data.error)
+ }
+
+ resolve(event.data)
+ }
+
+ client.postMessage(
+ message,
+ [channel.port2].concat(transferrables.filter(Boolean)),
+ )
+ })
+}
+
+async function respondWithMock(response) {
+ // Setting response status code to 0 is a no-op.
+ // However, when responding with a "Response.error()", the produced Response
+ // instance will have status code set to 0. Since it's not possible to create
+ // a Response instance with status code 0, handle that use-case separately.
+ if (response.status === 0) {
+ return Response.error()
+ }
+
+ const mockedResponse = new Response(response.body, response)
+
+ Reflect.defineProperty(mockedResponse, IS_MOCKED_RESPONSE, {
+ value: true,
+ enumerable: true,
+ })
+
+ return mockedResponse
+}
diff --git a/examples/with-apollo/server/server.ts b/examples/with-apollo/server/server.ts
new file mode 100644
index 0000000..f567c8f
--- /dev/null
+++ b/examples/with-apollo/server/server.ts
@@ -0,0 +1,68 @@
+import { ApolloServer } from '@apollo/server'
+import { PubSub } from 'graphql-subscriptions'
+import { makeExecutableSchema } from '@graphql-tools/schema'
+
+const pubsub = new PubSub()
+
+const typeDefs = `
+type Book {
+ id: ID!
+ title: String!
+}
+
+type Query {
+ books: [Book]
+}
+
+type Mutation {
+ addBook(title: String!): Book
+}
+
+type Subscription {
+ bookAdded: Book
+}
+`
+
+const books = [
+ {
+ id: '1',
+ title: 'Harry Potter and the Chamber of Secrets',
+ },
+ {
+ id: '2',
+ title: 'Jurassic Park',
+ },
+]
+
+const resolvers = {
+ Query: {
+ books: () => books,
+ },
+ Mutation: {
+ async addBook(root, args) {
+ const newBook = {
+ id: String(books.length + 1),
+ title: args.title,
+ }
+
+ books.push(newBook)
+ await pubsub.publish('BOOK_ADDED', { bookAdded: newBook })
+
+ return newBook
+ },
+ },
+ Subscription: {
+ bookAdded: {
+ subscribe: () => pubsub.asyncIterableIterator('BOOK_ADDED'),
+ },
+ },
+}
+
+export const schema = makeExecutableSchema({
+ typeDefs,
+ resolvers,
+})
+
+export const server = new ApolloServer({
+ schema,
+})
diff --git a/examples/with-apollo/server/tsconfig.json b/examples/with-apollo/server/tsconfig.json
new file mode 100644
index 0000000..a40f8eb
--- /dev/null
+++ b/examples/with-apollo/server/tsconfig.json
@@ -0,0 +1,12 @@
+{
+ "compilerOptions": {
+ "rootDirs": ["src"],
+ "outDir": "dist",
+ "lib": ["es2020"],
+ "target": "es2020",
+ "module": "esnext",
+ "moduleResolution": "node",
+ "esModuleInterop": true,
+ "types": ["node"]
+ }
+}
diff --git a/examples/with-apollo/src/App.tsx b/examples/with-apollo/src/App.tsx
new file mode 100644
index 0000000..3ec045f
--- /dev/null
+++ b/examples/with-apollo/src/App.tsx
@@ -0,0 +1,94 @@
+import { useEffect } from 'react'
+import { useQuery, gql, useMutation } from '@apollo/client'
+
+const BOOKS_QUERY = gql`
+ query GetBooks {
+ books {
+ id
+ title
+ }
+ }
+`
+
+const ADD_BOOK = gql`
+ mutation AddBook($title: String!) {
+ addBook(title: $title) {
+ id
+ }
+ }
+`
+
+const BOOKS_SUBSCRIPTION = gql`
+ subscription {
+ bookAdded {
+ id
+ title
+ }
+ }
+`
+
+type Book = {
+ id: string
+ title: string
+}
+
+export default function App() {
+ const { loading, error, data, subscribeToMore } = useQuery<{ books: Book[] }>(
+ BOOKS_QUERY,
+ )
+ const [addBook] = useMutation(ADD_BOOK)
+
+ useEffect(() => {
+ const terminateSubscription = subscribeToMore({
+ document: BOOKS_SUBSCRIPTION,
+ updateQuery(prev, { subscriptionData }) {
+ // @ts-ignore
+ const nextBook = subscriptionData.data.bookAdded
+ return Object.assign({}, prev, {
+ books: prev.books.concat(nextBook),
+ })
+ },
+ })
+
+ return terminateSubscription
+ }, [])
+
+ const handleAddBook = async (event: React.FormEvent) => {
+ event.preventDefault()
+ const form = event.currentTarget
+ const data = new FormData(form)
+ await addBook({
+ variables: {
+ title: data.get('title') as string,
+ },
+ onCompleted() {
+ form.reset()
+ },
+ })
+ }
+
+ if (loading) {
+ return Fetching...
+ }
+
+ if (error) {
+ return Failed to fetch! {error.message}
+ }
+
+ return (
+
+
+ {data?.books.map((book) => (
+ - {book.title}
+ ))}
+
+
+
+
+
+