@zimic/interceptor 0.14.0 → 0.15.0-canary.1

package/README.md

@@ -149,7 +149,7 @@ Check our [getting started guide](https://github.com/zimicjs/zimic/wiki/getting
     const interceptor = httpInterceptor.create<Schema>({
       type: 'local',
       baseURL: 'http://localhost:3000',
-      saveRequests: true, // Allow access to `handler.requests()`
+      saveRequests: true, // Allow access to `handler.requests`
     });
     ```
 
@@ -227,21 +227,20 @@ Check our [getting started guide](https://github.com/zimicjs/zimic/wiki/getting
     test('example', async () => {
       // Your application makes requests...
 
-      const requests = handler.requests();
-      expect(requests).toHaveLength(1);
+      expect(handler.requests).toHaveLength(1);
 
-      expect(requests[0].headers.get('authorization')).toBe('Bearer my-token');
+      expect(handler.requests[0].headers.get('authorization')).toBe('Bearer my-token');
 
-      expect(requests[0].searchParams.size).toBe(1);
-      expect(requests[0].searchParams.get('username')).toBe('my');
+      expect(handler.requests[0].searchParams.size).toBe(1);
+      expect(handler.requests[0].searchParams.get('username')).toBe('my');
 
-      expect(requests[0].body).toBe(null);
+      expect(handler.requests[0].body).toBe(null);
     });
     ```
 
 > [!NOTE]
 >
-> The 5.2 checks the application requests manually. This is optional in this example because the
+> Step 5.2 manually verifies the requests made by the application. This is optional in this example because the
 > [`with`](https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-handlerwithrestriction) and
 > [`times`](https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-handlertimes) calls (step 5.1) already
 > act as a declarative validation, expressing that exactly one request is expected with specific data. If fewer or more

package/dist/{chunk-FEGMEAEO.mjs → chunk-3O3YPVEG.mjs}

@@ -273,26 +273,14 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
   static {
     __name(this, "HttpInterceptorWorker");
   }
-  _platform = null;
-  _isRunning = false;
+  platform = null;
+  isRunning = false;
   startingPromise;
   stoppingPromise;
   store = new HttpInterceptorWorkerStore_default();
   runningInterceptors = [];
-  platform() {
-    return this._platform;
-  }
-  setPlatform(platform) {
-    this._platform = platform;
-  }
-  isRunning() {
-    return this._isRunning;
-  }
-  setIsRunning(isRunning) {
-    this._isRunning = isRunning;
-  }
   async sharedStart(internalStart) {
-    if (this.isRunning()) {
+    if (this.isRunning) {
       return;
     }
     if (this.startingPromise) {
@@ -311,7 +299,7 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
     }
   }
   async sharedStop(internalStop) {
-    if (!this.isRunning()) {
+    if (!this.isRunning) {
       return;
     }
     if (this.stoppingPromise) {
@@ -376,8 +364,7 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
   }
   findInterceptorByRequestBaseURL(request) {
     const interceptor = this.runningInterceptors.findLast((interceptor2) => {
-      const baseURL = interceptor2.baseURL();
-      return request.url.startsWith(baseURL);
+      return request.url.startsWith(interceptor2.baseURLAsString);
     });
     return interceptor;
   }
@@ -393,12 +380,11 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
     return defaultStrategyOrFactory;
   }
   async getInterceptorUnhandledRequestStrategy(request, interceptor) {
-    const interceptorStrategyOrFactory = interceptor.onUnhandledRequest();
-    if (typeof interceptorStrategyOrFactory === "function") {
+    if (typeof interceptor.onUnhandledRequest === "function") {
       const parsedRequest = await _HttpInterceptorWorker.parseRawUnhandledRequest(request);
-      return interceptorStrategyOrFactory(parsedRequest);
+      return interceptor.onUnhandledRequest(parsedRequest);
     }
-    return interceptorStrategyOrFactory;
+    return interceptor.onUnhandledRequest;
   }
   static createResponseFromDeclaration(request, declaration) {
     const headers = new HttpHeaders(declaration.headers);
@@ -838,24 +824,18 @@ var WebSocketHandler = class {
     __name(this, "WebSocketHandler");
   }
   sockets = /* @__PURE__ */ new Set();
-  _socketTimeout;
-  _messageTimeout;
+  socketTimeout;
+  messageTimeout;
   channelListeners = {};
   socketListeners = {
     messageAbort: /* @__PURE__ */ new Map()
   };
   constructor(options) {
-    this._socketTimeout = options.socketTimeout ?? DEFAULT_WEB_SOCKET_LIFECYCLE_TIMEOUT;
-    this._messageTimeout = options.messageTimeout ?? DEFAULT_WEB_SOCKET_MESSAGE_TIMEOUT;
-  }
-  socketTimeout() {
-    return this._socketTimeout;
-  }
-  messageTimeout() {
-    return this._messageTimeout;
+    this.socketTimeout = options.socketTimeout ?? DEFAULT_WEB_SOCKET_LIFECYCLE_TIMEOUT;
+    this.messageTimeout = options.messageTimeout ?? DEFAULT_WEB_SOCKET_MESSAGE_TIMEOUT;
   }
   async registerSocket(socket) {
-    const openPromise = waitForOpenClientSocket(socket, { timeout: this._socketTimeout });
+    const openPromise = waitForOpenClientSocket(socket, { timeout: this.socketTimeout });
     const handleSocketMessage = /* @__PURE__ */ __name(async (rawMessage) => {
       await this.handleSocketMessage(socket, rawMessage);
     }, "handleSocketMessage");
@@ -942,7 +922,7 @@ var WebSocketHandler = class {
   }
   async closeClientSockets(sockets = this.sockets) {
     const closingPromises = Array.from(sockets, async (socket) => {
-      await closeClientSocket(socket, { timeout: this._socketTimeout });
+      await closeClientSocket(socket, { timeout: this.socketTimeout });
     });
     await Promise.all(closingPromises);
   }
@@ -974,9 +954,9 @@ var WebSocketHandler = class {
       const replyTimeout = setTimeout(() => {
         this.offReply(channel, replyListener);
         this.offAbortSocketMessages(sockets, abortListener);
-        const timeoutError = new WebSocketMessageTimeoutError(this._messageTimeout);
+        const timeoutError = new WebSocketMessageTimeoutError(this.messageTimeout);
         reject(timeoutError);
-      }, this._messageTimeout);
+      }, this.messageTimeout);
       const abortListener = this.onAbortSocketMessages(sockets, (error) => {
         clearTimeout(replyTimeout);
         this.offReply(channel, replyListener);
@@ -998,7 +978,7 @@ var WebSocketHandler = class {
   }
   async reply(request, replyData, options) {
     const reply = await this.createReplyMessage(request, replyData);
-    if (this.isRunning()) {
+    if (this.isRunning) {
       this.sendMessage(reply, options.sockets);
     }
   }
@@ -1013,7 +993,7 @@ var WebSocketHandler = class {
     return replyMessage;
   }
   sendMessage(message, sockets = this.sockets) {
-    if (!this.isRunning()) {
+    if (!this.isRunning) {
       throw new NotStartedWebSocketHandlerError_default();
     }
     const stringifiedMessage = JSON.stringify(message);
@@ -1093,11 +1073,11 @@ var WebSocketServer = class extends WebSocketHandler_default {
     });
     this.httpServer = options.httpServer;
   }
-  isRunning() {
+  get isRunning() {
     return this.webSocketServer !== void 0;
   }
   start() {
-    if (this.isRunning()) {
+    if (this.isRunning) {
       return;
     }
     const webSocketServer = new ServerSocket({ server: this.httpServer });
@@ -1114,13 +1094,13 @@ var WebSocketServer = class extends WebSocketHandler_default {
     this.webSocketServer = webSocketServer;
   }
   async stop() {
-    if (!this.webSocketServer || !this.isRunning()) {
+    if (!this.webSocketServer || !this.isRunning) {
       return;
     }
     super.removeAllChannelListeners();
     super.abortSocketMessages();
     await super.closeClientSockets();
-    await closeServerSocket(this.webSocketServer, { timeout: this.socketTimeout() });
+    await closeServerSocket(this.webSocketServer, { timeout: this.socketTimeout });
     this.webSocketServer.removeAllListeners();
     this.webSocketServer = void 0;
   }
@@ -1182,11 +1162,11 @@ var InterceptorServer = class {
   static {
     __name(this, "InterceptorServer");
   }
-  _httpServer;
-  _webSocketServer;
-  _hostname;
-  _port;
-  _logUnhandledRequests;
+  httpServer;
+  webSocketServer;
+  hostname;
+  port;
+  logUnhandledRequests;
   httpHandlerGroups = {
     GET: [],
     POST: [],
@@ -1198,68 +1178,57 @@ var InterceptorServer = class {
   };
   knownWorkerSockets = /* @__PURE__ */ new Set();
   constructor(options) {
-    this._hostname = options.hostname ?? "localhost";
-    this._port = options.port;
-    this._logUnhandledRequests = options.logUnhandledRequests ?? DEFAULT_LOG_UNHANDLED_REQUESTS;
-  }
-  hostname() {
-    return this._hostname;
-  }
-  port() {
-    return this._port;
-  }
-  logUnhandledRequests() {
-    return this._logUnhandledRequests;
+    this.hostname = options.hostname ?? "localhost";
+    this.port = options.port;
+    this.logUnhandledRequests = options.logUnhandledRequests ?? DEFAULT_LOG_UNHANDLED_REQUESTS;
   }
-  httpURL() {
-    if (this._port === void 0) {
+  get httpURL() {
+    if (this.port === void 0) {
       return void 0;
     }
-    return `http://${this._hostname}:${this._port}`;
+    return `http://${this.hostname}:${this.port}`;
   }
-  isRunning() {
-    return !!this._httpServer?.listening && !!this._webSocketServer?.isRunning();
+  get isRunning() {
+    return !!this.httpServer?.listening && !!this.webSocketServer?.isRunning;
   }
-  httpServer() {
-    if (!this._httpServer) {
+  get httpServerOrThrow() {
+    if (!this.httpServer) {
       throw new NotStartedInterceptorServerError_default();
     }
-    return this._httpServer;
+    return this.httpServer;
   }
-  webSocketServer() {
-    if (!this._webSocketServer) {
+  get webSocketServerOrThrow() {
+    if (!this.webSocketServer) {
       throw new NotStartedInterceptorServerError_default();
     }
-    return this._webSocketServer;
+    return this.webSocketServer;
   }
   async start() {
-    if (this.isRunning()) {
+    if (this.isRunning) {
       return;
     }
-    this._httpServer = createServer({
+    this.httpServer = createServer({
       keepAlive: true,
       joinDuplicateHeaders: true
     });
     await this.startHttpServer();
-    this._webSocketServer = new WebSocketServer_default({
-      httpServer: this._httpServer
+    this.webSocketServer = new WebSocketServer_default({
+      httpServer: this.httpServer
     });
     this.startWebSocketServer();
   }
   async startHttpServer() {
-    const httpServer = this.httpServer();
-    await startHttpServer(httpServer, {
-      hostname: this._hostname,
-      port: this._port
+    await startHttpServer(this.httpServerOrThrow, {
+      hostname: this.hostname,
+      port: this.port
     });
-    this._port = getHttpServerPort(httpServer);
-    httpServer.on("request", this.handleHttpRequest);
+    this.port = getHttpServerPort(this.httpServerOrThrow);
+    this.httpServerOrThrow.on("request", this.handleHttpRequest);
   }
   startWebSocketServer() {
-    const webSocketServer = this.webSocketServer();
-    webSocketServer.start();
-    webSocketServer.onEvent("interceptors/workers/use/commit", this.commitWorker);
-    webSocketServer.onEvent("interceptors/workers/use/reset", this.resetWorker);
+    this.webSocketServerOrThrow.start();
+    this.webSocketServerOrThrow.onEvent("interceptors/workers/use/commit", this.commitWorker);
+    this.webSocketServerOrThrow.onEvent("interceptors/workers/use/reset", this.resetWorker);
   }
   commitWorker = /* @__PURE__ */ __name((message, socket) => {
     const commit = message.data;
@@ -1272,7 +1241,7 @@ var InterceptorServer = class {
     const handlersToResetTo = message.data;
     const isWorkerNoLongerCommitted = handlersToResetTo === void 0;
     if (isWorkerNoLongerCommitted) {
-      this.webSocketServer().abortSocketMessages([socket]);
+      this.webSocketServerOrThrow.abortSocketMessages([socket]);
     } else {
       for (const handler of handlersToResetTo) {
         this.registerHttpHandler(handler, socket);
@@ -1310,25 +1279,23 @@ var InterceptorServer = class {
       removeArrayIndex(handlerGroups, socketIndex);
     }
   }
-  stop = /* @__PURE__ */ __name(async () => {
-    if (!this.isRunning()) {
+  async stop() {
+    if (!this.isRunning) {
       return;
     }
     await this.stopWebSocketServer();
     await this.stopHttpServer();
-  }, "stop");
+  }
   async stopHttpServer() {
-    const httpServer = this.httpServer();
-    await stopHttpServer(httpServer);
-    httpServer.removeAllListeners();
-    this._httpServer = void 0;
+    await stopHttpServer(this.httpServerOrThrow);
+    this.httpServerOrThrow.removeAllListeners();
+    this.httpServer = void 0;
   }
   async stopWebSocketServer() {
-    const webSocketServer = this.webSocketServer();
-    webSocketServer.offEvent("interceptors/workers/use/commit", this.commitWorker);
-    webSocketServer.offEvent("interceptors/workers/use/reset", this.resetWorker);
-    await webSocketServer.stop();
-    this._webSocketServer = void 0;
+    this.webSocketServerOrThrow.offEvent("interceptors/workers/use/commit", this.commitWorker);
+    this.webSocketServerOrThrow.offEvent("interceptors/workers/use/reset", this.resetWorker);
+    await this.webSocketServerOrThrow.stop();
+    this.webSocketServer = void 0;
   }
   handleHttpRequest = /* @__PURE__ */ __name(async (nodeRequest, nodeResponse) => {
     const request = normalizeNodeRequest(nodeRequest, await getFetchAPI());
@@ -1361,7 +1328,6 @@ var InterceptorServer = class {
     }
   }, "handleHttpRequest");
   async createResponseForRequest(request) {
-    const webSocketServer = this.webSocketServer();
     const methodHandlers = this.httpHandlerGroups[request.method];
     const requestURL = excludeURLParams_default(new URL(request.url)).toString();
     let matchedSomeInterceptor = false;
@@ -1372,7 +1338,7 @@ var InterceptorServer = class {
         continue;
       }
       matchedSomeInterceptor = true;
-      const { response: serializedResponse } = await webSocketServer.request(
+      const { response: serializedResponse } = await this.webSocketServerOrThrow.request(
         "interceptors/responses/create",
         { handlerId: handler.id, request },
         { sockets: [handler.socket] }
@@ -1396,11 +1362,10 @@ var InterceptorServer = class {
     }
   }
   async logUnhandledRequestIfNecessary(request, serializedRequest) {
-    const webSocketServer = this.webSocketServer();
     const handler = this.findHttpHandlerByRequestBaseURL(request);
     if (handler) {
       try {
-        const { wasLogged: wasRequestLoggedByRemoteInterceptor } = await webSocketServer.request(
+        const { wasLogged: wasRequestLoggedByRemoteInterceptor } = await this.webSocketServerOrThrow.request(
           "interceptors/responses/unhandled",
           { request: serializedRequest },
           { sockets: [handler.socket] }
@@ -1415,7 +1380,7 @@ var InterceptorServer = class {
         }
       }
     }
-    if (!this._logUnhandledRequests) {
+    if (!this.logUnhandledRequests) {
       return;
     }
     await HttpInterceptorWorker_default.logUnhandledRequestWarning(request, "reject");
@@ -1482,5 +1447,5 @@ var interceptorServer = Object.freeze(new InterceptorServerNamespace_default());
  * Since simulating this scenario is difficult, we are ignoring this branch fow now. */
 
 export { DEFAULT_ACCESS_CONTROL_HEADERS, DEFAULT_PREFLIGHT_STATUS_CODE, NotStartedInterceptorServerError_default, createCachedDynamicImport_default, interceptorServer, logWithPrefix };
-//# sourceMappingURL=chunk-FEGMEAEO.mjs.map
-//# sourceMappingURL=chunk-FEGMEAEO.mjs.map
+//# sourceMappingURL=chunk-3O3YPVEG.mjs.map
+//# sourceMappingURL=chunk-3O3YPVEG.mjs.map