@zimic/interceptor 1.3.6-canary.2 → 1.3.6-canary.4

package/dist/http.js

@@ -3,33 +3,11 @@
 var http = require('@zimic/http');
 var color2 = require('picocolors');
 var msw = require('msw');
-var mswBrowser = require('msw/browser');
-var mswNode = require('msw/node');
 var ClientSocket = require('isomorphic-ws');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
 var color2__default = /*#__PURE__*/_interopDefault(color2);
-var mswBrowser__namespace = /*#__PURE__*/_interopNamespace(mswBrowser);
-var mswNode__namespace = /*#__PURE__*/_interopNamespace(mswNode);
 var ClientSocket__default = /*#__PURE__*/_interopDefault(ClientSocket);
 
 // src/http/index.ts
@@ -1740,8 +1718,14 @@ var HttpInterceptorImplementation = class {
   }
 };
 var HttpInterceptorImplementation_default = HttpInterceptorImplementation;
-var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
-  internalWorker;
+var importMSWNode = createCachedDynamicImport_default(() => import('msw/node'));
+var importMSWBrowser = createCachedDynamicImport_default(() => import('msw/browser'));
+var LocalHttpInterceptorWorker = class _LocalHttpInterceptorWorker extends HttpInterceptorWorker_default {
+  // Re-creating MSW workers may cause issues, so we should keep a single worker instance, even if all interceptor
+  // workers are stopped. See https://github.com/mswjs/msw/issues/2597.
+  static mswWorker;
+  static isMSWWorkerRunning = false;
+  mswHttpHandler;
   httpHandlersByMethod = {
     GET: [],
     POST: [],
@@ -1754,52 +1738,66 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
   constructor(_options) {
     super();
   }
+  get class() {
+    return _LocalHttpInterceptorWorker;
+  }
   get type() {
     return "local";
   }
-  get internalWorkerOrThrow() {
-    if (!this.internalWorker) {
+  get mswWorkerOrThrow() {
+    if (!this.class.mswWorker) {
       throw new NotRunningHttpInterceptorError_default();
     }
-    return this.internalWorker;
+    return this.class.mswWorker;
   }
-  get internalWorkerOrCreate() {
-    this.internalWorker ??= this.createInternalWorker();
-    return this.internalWorker;
+  async getMSWWorkerOrCreate() {
+    this.class.mswWorker ??= await this.createMSWWorker();
+    return this.class.mswWorker;
   }
-  createInternalWorker() {
-    const mswHttpHandler = msw.http.all("*", async (context) => {
-      const request = context.request;
-      const response = await this.createResponseForRequest(request);
-      return response;
-    });
-    if (isServerSide() && "setupServer" in mswNode__namespace) {
-      return mswNode__namespace.setupServer(mswHttpHandler);
+  async createMSWWorker() {
+    if (isServerSide()) {
+      const mswNode = await importMSWNode();
+      if ("setupServer" in mswNode) {
+        return mswNode.setupServer();
+      }
     }
-    if (isClientSide() && "setupWorker" in mswBrowser__namespace) {
-      return mswBrowser__namespace.setupWorker(mswHttpHandler);
+    if (isClientSide()) {
+      const mswBrowser = await importMSWBrowser();
+      if ("setupWorker" in mswBrowser) {
+        return mswBrowser.setupWorker();
+      }
     }
     throw new UnknownHttpInterceptorPlatformError_default();
   }
   async start() {
     await super.sharedStart(async () => {
-      const internalWorker = this.internalWorkerOrCreate;
+      const mswWorker = await this.getMSWWorkerOrCreate();
       const sharedOptions = {
         onUnhandledRequest: "bypass"
       };
-      if (this.isInternalBrowserWorker(internalWorker)) {
+      this.mswHttpHandler = msw.http.all("*", async (context) => {
+        const request = context.request;
+        const response = await this.createResponseForRequest(request);
+        return response;
+      });
+      mswWorker.use(this.mswHttpHandler);
+      if (this.isInternalBrowserWorker(mswWorker)) {
         this.platform = "browser";
-        await this.startInBrowser(internalWorker, sharedOptions);
+        if (!this.class.isMSWWorkerRunning) {
+          await this.startInBrowser(mswWorker, sharedOptions);
+          this.class.isMSWWorkerRunning = true;
+        }
       } else {
         this.platform = "node";
-        this.startInNode(internalWorker, sharedOptions);
+        this.startInNode(mswWorker, sharedOptions);
+        this.class.isMSWWorkerRunning = true;
       }
       this.isRunning = true;
     });
   }
-  async startInBrowser(internalWorker, sharedOptions) {
+  async startInBrowser(mswWorker, sharedOptions) {
     try {
-      await internalWorker.start({ ...sharedOptions, quiet: true });
+      await mswWorker.start({ ...sharedOptions, quiet: true });
     } catch (error) {
       this.handleBrowserWorkerStartError(error);
     }
@@ -1807,36 +1805,35 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
   handleBrowserWorkerStartError(error) {
     if (UnregisteredBrowserServiceWorkerError_default.matchesRawError(error)) {
       throw new UnregisteredBrowserServiceWorkerError_default();
+    } else {
+      throw error;
     }
-    throw error;
   }
-  startInNode(internalWorker, sharedOptions) {
-    internalWorker.listen(sharedOptions);
+  startInNode(mswWorker, sharedOptions) {
+    mswWorker.listen(sharedOptions);
   }
   async stop() {
-    await super.sharedStop(() => {
-      const internalWorker = this.internalWorkerOrCreate;
-      if (this.isInternalBrowserWorker(internalWorker)) {
-        this.stopInBrowser(internalWorker);
-      } else {
-        this.stopInNode(internalWorker);
-      }
+    await super.sharedStop(async () => {
+      const mswWorker = await this.getMSWWorkerOrCreate();
       this.clearHandlers();
-      this.internalWorker = void 0;
+      const newMSWHandlers = mswWorker.listHandlers().filter((handler) => handler !== this.mswHttpHandler);
+      mswWorker.resetHandlers(...newMSWHandlers);
+      if (this.isInternalBrowserWorker(mswWorker)) ; else {
+        this.stopInNode(mswWorker);
+        this.class.isMSWWorkerRunning = false;
+      }
+      this.mswHttpHandler = void 0;
       this.isRunning = false;
     });
   }
-  stopInBrowser(internalWorker) {
-    internalWorker.stop();
-  }
-  stopInNode(internalWorker) {
-    internalWorker.close();
+  stopInNode(mswWorker) {
+    mswWorker.close();
   }
   isInternalBrowserWorker(worker) {
     return "start" in worker && "stop" in worker;
   }
   hasInternalBrowserWorker() {
-    return this.isInternalBrowserWorker(this.internalWorkerOrThrow);
+    return this.isInternalBrowserWorker(this.mswWorkerOrThrow);
   }
   hasInternalNodeWorker() {
     return !this.hasInternalBrowserWorker();
@@ -2667,12 +2664,8 @@ var LocalHttpInterceptor = class {
     this.implementation = new HttpInterceptorImplementation_default({
       store: this.store,
       baseURL,
-      createWorker: () => {
-        return this.store.getOrCreateLocalWorker({});
-      },
-      deleteWorker: () => {
-        this.store.deleteLocalWorker();
-      },
+      createWorker: () => this.store.getOrCreateLocalWorker({}),
+      deleteWorker: () => this.store.deleteLocalWorker(),
       Handler: LocalHttpRequestHandler_default,
       onUnhandledRequest: options.onUnhandledRequest,
       requestSaving: options.requestSaving
@@ -2895,15 +2888,26 @@ var InvalidJSONError = class extends http.InvalidJSONError {
 };
 /* istanbul ignore else -- @preserve
  * The else is a fallback for when the error is not an instance of Error. */
+/* istanbul ignore next -- @preserve
+ * This if statement only runs if concurrent calls to stop() are made, which is an edge case that is hard to
+ * reliably reproduce in tests. */
 /* istanbul ignore if -- @preserve
  * This is just a type guard to ensure the value is valid. In practice, this condition should never be true. */
 /* istanbul ignore next -- @preserve
  * Ignoring because there will always be a handler for the given method and path at this point. */
 /* istanbul ignore if -- @preserve
  * Trying to access the internal worker when it does not exist should not happen. */
+/* istanbul ignore else -- @preserve
+ * We still check if we actually imported the server module in case our `isServerSide()` check returns true, but
+ * the environment actually resolves the browser module. */
 /* istanbul ignore else -- @preserve */
+/* istanbul ignore else -- @preserve
+ * We still check if we actually imported the browser module in case our `isClientSide()` check returns true, but
+ * the environment actually resolves the server module. */
 /* istanbul ignore next -- @preserve
  * Ignoring because checking unknown platforms is not configured in our test setup. */
+/* istanbul ignore else -- @preserve
+ * Since we start the internal worker once and do not stop it, tests may not be able exercise this branch. */
 /* istanbul ignore next -- @preserve
  * Ignoring as Node.js >=20 provides a global crypto and the import fallback won't run. */
 /* istanbul ignore else -- @preserve