@zimic/interceptor 0.17.0-canary.3 → 0.17.0-canary.4

package/dist/server.js

@@ -1,29 +1,29 @@
 'use strict';
 
-var chunkPURXNE6R_js = require('./chunk-PURXNE6R.js');
+var chunkMXHLBRPB_js = require('./chunk-MXHLBRPB.js');
 require('./chunk-WCQVDF3K.js');
 
 
 
 Object.defineProperty(exports, "DEFAULT_ACCESS_CONTROL_HEADERS", {
   enumerable: true,
-  get: function () { return chunkPURXNE6R_js.DEFAULT_ACCESS_CONTROL_HEADERS; }
+  get: function () { return chunkMXHLBRPB_js.DEFAULT_ACCESS_CONTROL_HEADERS; }
 });
 Object.defineProperty(exports, "DEFAULT_PREFLIGHT_STATUS_CODE", {
   enumerable: true,
-  get: function () { return chunkPURXNE6R_js.DEFAULT_PREFLIGHT_STATUS_CODE; }
+  get: function () { return chunkMXHLBRPB_js.DEFAULT_PREFLIGHT_STATUS_CODE; }
 });
 Object.defineProperty(exports, "NotRunningInterceptorServerError", {
   enumerable: true,
-  get: function () { return chunkPURXNE6R_js.NotRunningInterceptorServerError_default; }
+  get: function () { return chunkMXHLBRPB_js.NotRunningInterceptorServerError_default; }
 });
 Object.defineProperty(exports, "RunningInterceptorServerError", {
   enumerable: true,
-  get: function () { return chunkPURXNE6R_js.RunningInterceptorServerError_default; }
+  get: function () { return chunkMXHLBRPB_js.RunningInterceptorServerError_default; }
 });
 Object.defineProperty(exports, "createInterceptorServer", {
   enumerable: true,
-  get: function () { return chunkPURXNE6R_js.createInterceptorServer; }
+  get: function () { return chunkMXHLBRPB_js.createInterceptorServer; }
 });
 //# sourceMappingURL=server.js.map
 //# sourceMappingURL=server.js.map

package/dist/server.mjs

@@ -1,4 +1,4 @@
-export { DEFAULT_ACCESS_CONTROL_HEADERS, DEFAULT_PREFLIGHT_STATUS_CODE, NotRunningInterceptorServerError_default as NotRunningInterceptorServerError, RunningInterceptorServerError_default as RunningInterceptorServerError, createInterceptorServer } from './chunk-L75WKVZO.mjs';
+export { DEFAULT_ACCESS_CONTROL_HEADERS, DEFAULT_PREFLIGHT_STATUS_CODE, NotRunningInterceptorServerError_default as NotRunningInterceptorServerError, RunningInterceptorServerError_default as RunningInterceptorServerError, createInterceptorServer } from './chunk-OGL76CKO.mjs';
 import './chunk-CGILA3WO.mjs';
 //# sourceMappingURL=server.mjs.map
 //# sourceMappingURL=server.mjs.map

package/package.json

@@ -14,7 +14,7 @@
     "api",
     "static"
   ],
-  "version": "0.17.0-canary.3",
+  "version": "0.17.0-canary.4",
   "repository": {
     "type": "git",
     "url": "https://github.com/zimicjs/zimic.git",
@@ -101,8 +101,8 @@
     "vitest": "^3.1.1",
     "@zimic/eslint-config-node": "0.0.0",
     "@zimic/lint-staged-config": "0.0.0",
-    "@zimic/tsconfig": "0.0.0",
-    "@zimic/utils": "0.0.0"
+    "@zimic/utils": "0.0.0",
+    "@zimic/tsconfig": "0.0.0"
   },
   "peerDependencies": {
     "@zimic/http": "^0.3.0 || ^0.3.0-canary.0",

package/src/http/interceptor/LocalHttpInterceptor.ts

@@ -18,10 +18,10 @@ class LocalHttpInterceptor<Schema extends HttpSchema> implements PublicLocalHttp
     this.client = new HttpInterceptorClient<Schema, typeof LocalHttpRequestHandler>({
       store: this.store,
       baseURL,
-      createWorker() {
+      createWorker: () => {
         return this.store.getOrCreateLocalWorker({});
       },
-      deleteWorker() {
+      deleteWorker: () => {
         this.store.deleteLocalWorker();
       },
       Handler: LocalHttpRequestHandler,

package/src/http/interceptor/RemoteHttpInterceptor.ts

@@ -1,6 +1,7 @@
 import { HttpSchema, HttpSchemaMethod, HttpSchemaPath } from '@zimic/http';
 
 import RemoteHttpRequestHandler from '../requestHandler/RemoteHttpRequestHandler';
+import RunningHttpInterceptorError from './errors/RunningHttpInterceptorError';
 import HttpInterceptorClient from './HttpInterceptorClient';
 import HttpInterceptorStore from './HttpInterceptorStore';
 import { AsyncHttpInterceptorMethodHandler } from './types/handlers';
@@ -9,22 +10,25 @@ import { HttpInterceptorRequestSaving, RemoteHttpInterceptor as PublicRemoteHttp
 
 class RemoteHttpInterceptor<Schema extends HttpSchema> implements PublicRemoteHttpInterceptor<Schema> {
   private store = new HttpInterceptorStore();
-
   client: HttpInterceptorClient<Schema, typeof RemoteHttpRequestHandler>;
 
+  private _auth?: RemoteHttpInterceptorOptions['auth'];
+
   constructor(options: RemoteHttpInterceptorOptions) {
+    this._auth = options.auth;
+
     const baseURL = new URL(options.baseURL);
 
     this.client = new HttpInterceptorClient<Schema, typeof RemoteHttpRequestHandler>({
       store: this.store,
       baseURL,
-      createWorker() {
+      createWorker: () => {
         return this.store.getOrCreateRemoteWorker({
           serverURL: new URL(baseURL.origin),
-          auth: options.auth,
+          auth: this._auth,
         });
       },
-      deleteWorker() {
+      deleteWorker: () => {
         this.store.deleteRemoteWorker(baseURL, { auth: options.auth });
       },
       Handler: RemoteHttpRequestHandler,
@@ -53,6 +57,33 @@ class RemoteHttpInterceptor<Schema extends HttpSchema> implements PublicRemoteHt
     this.client.requestSaving = requestSaving;
   }
 
+  get auth() {
+    return this._auth;
+  }
+
+  set auth(auth: RemoteHttpInterceptorOptions['auth'] | undefined) {
+    const cannotChangeAuthWhileRunningMessage =
+      'Did you forget to call `await interceptor.stop()` before changing the authentication parameters?';
+
+    if (this.isRunning) {
+      throw new RunningHttpInterceptorError(cannotChangeAuthWhileRunningMessage);
+    }
+
+    if (!auth) {
+      this._auth = undefined;
+      return;
+    }
+
+    this._auth = new Proxy(auth, {
+      set: (target, property, value) => {
+        if (this.isRunning) {
+          throw new RunningHttpInterceptorError(cannotChangeAuthWhileRunningMessage);
+        }
+        return Reflect.set(target, property, value);
+      },
+    });
+  }
+
   get onUnhandledRequest() {
     return this.client.onUnhandledRequest;
   }

package/src/http/interceptor/errors/RunningHttpInterceptorError.ts

@@ -7,7 +7,7 @@
  */
 class RunningHttpInterceptorError extends Error {
   constructor(additionalMessage: string) {
-    super(`The interceptor is running.${additionalMessage}`);
+    super(`The interceptor is running. ${additionalMessage}`);
     this.name = 'RunningHttpInterceptorError';
   }
 }

package/src/http/interceptor/types/public.ts

@@ -1,7 +1,7 @@
 import { HttpSchema } from '@zimic/http';
 
 import { SyncHttpInterceptorMethodHandler, AsyncHttpInterceptorMethodHandler } from './handlers';
-import { HttpInterceptorPlatform, UnhandledRequestStrategy } from './options';
+import { HttpInterceptorPlatform, RemoteHttpInterceptorOptions, UnhandledRequestStrategy } from './options';
 
 /**
  * Configures if the intercepted requests are saved and how they are handled.
@@ -163,7 +163,7 @@ export interface LocalHttpInterceptor<Schema extends HttpSchema> extends HttpInt
    *
    * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#unhandled-requests Unhandled requests}
    */
-  onUnhandledRequest: UnhandledRequestStrategy.Local | undefined;
+  onUnhandledRequest?: UnhandledRequestStrategy.Local;
 
   /**
    * Creates a GET
@@ -367,6 +367,14 @@ export interface RemoteHttpInterceptor<Schema extends HttpSchema> extends HttpIn
   /** @readonly */
   get type(): 'remote';
 
+  /**
+   * Options to authenticate the interceptor when connecting to an interceptor server. This is required if the
+   * interceptor server was started with the `--tokens-dir` option.
+   *
+   * @see {@link https://github.com/zimicjs/zimic/wiki/cli‐zimic‐interceptor‐server#authentication Interceptor server authentication}
+   */
+  auth?: RemoteHttpInterceptorOptions['auth'];
+
   /**
    * The strategy to use for unhandled requests. If a request starts with the base URL of the interceptor, but no
    * matching handler exists, this strategy will be used. If a function is provided, it will be called with the
@@ -374,7 +382,7 @@ export interface RemoteHttpInterceptor<Schema extends HttpSchema> extends HttpIn
    *
    * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#unhandled-requests Unhandled requests}
    */
-  onUnhandledRequest: UnhandledRequestStrategy.Remote | undefined;
+  onUnhandledRequest?: UnhandledRequestStrategy.Remote;
 
   /**
    * Creates a GET

package/src/server/utils/auth.ts

@@ -174,11 +174,10 @@ export async function readInterceptorTokenFromFile(
   return validation.data.token;
 }
 
-export async function createInterceptorToken(options: {
-  name?: string;
-  tokensDirectory: string;
-}): Promise<InterceptorToken> {
-  const { name, tokensDirectory } = options;
+export async function createInterceptorToken(
+  options: { name?: string; tokensDirectory?: string } = {},
+): Promise<InterceptorToken> {
+  const { name, tokensDirectory = DEFAULT_INTERCEPTOR_TOKENS_DIRECTORY } = options;
 
   const tokensDirectoryExists = await pathExists(tokensDirectory);
 
@@ -226,14 +225,16 @@ export async function createInterceptorToken(options: {
   return token;
 }
 
-export async function listInterceptorTokens(options: { tokensDirectory: string }) {
-  const tokensDirectoryExists = await pathExists(options.tokensDirectory);
+export async function listInterceptorTokens(options: { tokensDirectory?: string } = {}) {
+  const { tokensDirectory = DEFAULT_INTERCEPTOR_TOKENS_DIRECTORY } = options;
+
+  const tokensDirectoryExists = await pathExists(tokensDirectory);
 
   if (!tokensDirectoryExists) {
     return [];
   }
 
-  const files = await fs.promises.readdir(options.tokensDirectory);
+  const files = await fs.promises.readdir(tokensDirectory);
 
   const tokenReadPromises = files.map(async (file) => {
     if (!isValidInterceptorTokenId(file)) {
@@ -241,7 +242,7 @@ export async function listInterceptorTokens(options: { tokensDirectory: string }
     }
 
     const tokenId = file;
-    const token = await readInterceptorTokenFromFile(tokenId, options);
+    const token = await readInterceptorTokenFromFile(tokenId, { tokensDirectory });
     return token;
   });
 
@@ -288,14 +289,16 @@ export async function validateInterceptorToken(tokenValue: string, options: { to
   }
 }
 
-export async function removeInterceptorToken(tokenId: string, options: { tokensDirectory: string }) {
+export async function removeInterceptorToken(tokenId: string, options: { tokensDirectory?: string } = {}) {
+  const { tokensDirectory = DEFAULT_INTERCEPTOR_TOKENS_DIRECTORY } = options;
+
   /* istanbul ignore if -- @preserve
    * At this point, we should have a valid tokenId. This is just a sanity check. */
   if (!isValidInterceptorTokenId(tokenId)) {
     throw new InvalidInterceptorTokenError(tokenId);
   }
 
-  const tokenFilePath = path.join(options.tokensDirectory, tokenId);
+  const tokenFilePath = path.join(tokensDirectory, tokenId);
 
   await fs.promises.rm(tokenFilePath, { force: true });
 }