@appium/base-driver 10.5.2 → 10.7.0

package/lib/jsonwp-proxy/protocol-converter.ts

@@ -1,5 +1,4 @@
 import type {AppiumLogger, HTTPBody, ProxyResponse} from '@appium/types';
-import _ from 'lodash';
 import {logger, util} from '@appium/support';
 import {duplicateKeys} from '../basedriver/helpers';
 import {MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY, PROTOCOLS} from '../constants';
@@ -7,7 +6,7 @@ import {MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY, PROTOCOLS} from '../constants';
 export type ProxyFunction = (
   url: string,
   method: string,
-  body?: HTTPBody
+  body?: HTTPBody,
 ) => Promise<[ProxyResponse, HTTPBody]>;
 
 export const COMMAND_URLS_CONFLICTS = [
@@ -20,7 +19,8 @@ export const COMMAND_URLS_CONFLICTS = [
   },
   {
     commandNames: ['getElementScreenshot'],
-    jsonwpConverter: (url: string) => url.replace(/\/element\/([^/]+)\/screenshot$/, '/screenshot/$1'),
+    jsonwpConverter: (url: string) =>
+      url.replace(/\/element\/([^/]+)\/screenshot$/, '/screenshot/$1'),
     w3cConverter: (url: string) => url.replace(/\/screenshot\/([^/]+)/, '/element/$1/screenshot'),
   },
   {
@@ -60,7 +60,7 @@ export class ProtocolConverter {
    */
   constructor(
     public proxyFunc: ProxyFunction,
-    log: AppiumLogger | null = null
+    log: AppiumLogger | null = null,
   ) {
     this._log = log;
   }
@@ -85,7 +85,7 @@ export class ProtocolConverter {
     commandName: string,
     url: string,
     method: string,
-    body?: HTTPBody
+    body?: HTTPBody,
   ): Promise<[ProxyResponse, HTTPBody]> {
     if (!this.downstreamProtocol) {
       return await this.proxyFunc(url, method, body);
@@ -118,12 +118,12 @@ export class ProtocolConverter {
         this.downstreamProtocol === MJSONWP ? jsonwpConverter(url) : w3cConverter(url);
       if (rewrittenUrl === url) {
         this.log.debug(
-          `Did not know how to rewrite the original URL '${url}' for ${this.downstreamProtocol} protocol`
+          `Did not know how to rewrite the original URL '${url}' for ${this.downstreamProtocol} protocol`,
         );
         break;
       }
       this.log.info(
-        `Rewrote the original URL '${url}' to '${rewrittenUrl}' for ${this.downstreamProtocol} protocol`
+        `Rewrote the original URL '${url}' to '${rewrittenUrl}' for ${this.downstreamProtocol} protocol`,
       );
       return await this.proxyFunc(rewrittenUrl, method, body);
     }
@@ -138,12 +138,16 @@ export class ProtocolConverter {
    * provided in the request, we need to do 3 proxies and combine the result.
    */
   private getTimeoutRequestObjects(body: HTTPBody): Record<string, unknown>[] {
-    if (_.isNil(body)) {
+    if (body == null) {
       return [];
     }
 
     const bodyObj = (util.safeJsonParse(body) as Record<string, unknown>) ?? {};
-    if (this.downstreamProtocol === W3C && _.has(bodyObj, 'ms') && _.has(bodyObj, 'type')) {
+    if (
+      this.downstreamProtocol === W3C &&
+      Object.hasOwn(bodyObj, 'ms') &&
+      Object.hasOwn(bodyObj, 'type')
+    ) {
       const typeToW3C = (x: string) => (x === 'page load' ? 'pageLoad' : x);
       return [
         {
@@ -152,15 +156,20 @@ export class ProtocolConverter {
       ];
     }
 
-    if (this.downstreamProtocol === MJSONWP && (!_.has(bodyObj, 'ms') || !_.has(bodyObj, 'type'))) {
+    if (
+      this.downstreamProtocol === MJSONWP &&
+      (!Object.hasOwn(bodyObj, 'ms') || !Object.hasOwn(bodyObj, 'type'))
+    ) {
       const typeToJSONWP = (x: string) => (x === 'pageLoad' ? 'page load' : x);
-      return _.toPairs(bodyObj)
-        // Only transform the entry if ms value is a valid positive float number
-        .filter((pair) => /^\d+(?:[.,]\d*?)?$/.test(`${pair[1]}`))
-        .map((pair) => ({
-          type: typeToJSONWP(pair[0]),
-          ms: pair[1],
-        }));
+      return (
+        Object.entries(bodyObj)
+          // Only transform the entry if ms value is a valid positive float number
+          .filter((pair) => /^\d+(?:[.,]\d*?)?$/.test(`${pair[1]}`))
+          .map((pair) => ({
+            type: typeToJSONWP(pair[0]),
+            ms: pair[1],
+          }))
+      );
     }
 
     return [bodyObj];
@@ -172,14 +181,14 @@ export class ProtocolConverter {
   private async proxySetTimeouts(
     url: string,
     method: string,
-    body?: HTTPBody
+    body?: HTTPBody,
   ): Promise<[ProxyResponse, HTTPBody]> {
     const timeoutRequestObjects = this.getTimeoutRequestObjects(body);
     if (timeoutRequestObjects.length === 0) {
       return await this.proxyFunc(url, method, body);
     }
     this.log.debug(
-      `Will send the following request bodies to /timeouts: ${JSON.stringify(timeoutRequestObjects)}`
+      `Will send the following request bodies to /timeouts: ${JSON.stringify(timeoutRequestObjects)}`,
     );
 
     let response!: ProxyResponse;
@@ -203,19 +212,23 @@ export class ProtocolConverter {
   private async proxySetWindow(
     url: string,
     method: string,
-    body: HTTPBody
+    body: HTTPBody,
   ): Promise<[ProxyResponse, HTTPBody]> {
     const bodyObj = util.safeJsonParse(body);
-    if (_.isPlainObject(bodyObj)) {
+    if (util.isPlainObject(bodyObj)) {
       const obj = bodyObj as Record<string, unknown>;
-      if (this.downstreamProtocol === W3C && _.has(bodyObj, 'name') && !_.has(bodyObj, 'handle')) {
+      if (
+        this.downstreamProtocol === W3C &&
+        Object.hasOwn(bodyObj, 'name') &&
+        !Object.hasOwn(bodyObj, 'handle')
+      ) {
         this.log.debug(`Copied 'name' value '${obj.name}' to 'handle' as per W3C spec`);
         return await this.proxyFunc(url, method, {...obj, handle: obj.name});
       }
       if (
         this.downstreamProtocol === MJSONWP &&
-        _.has(bodyObj, 'handle') &&
-        !_.has(bodyObj, 'name')
+        Object.hasOwn(bodyObj, 'handle') &&
+        !Object.hasOwn(bodyObj, 'name')
       ) {
         this.log.debug(`Copied 'handle' value '${obj.handle}' to 'name' as per JSONWP spec`);
         return await this.proxyFunc(url, method, {...obj, name: obj.handle});
@@ -227,16 +240,19 @@ export class ProtocolConverter {
   private async proxySetValue(
     url: string,
     method: string,
-    body: HTTPBody
+    body: HTTPBody,
   ): Promise<[ProxyResponse, HTTPBody]> {
     const bodyObj = util.safeJsonParse(body) as Record<string, unknown> | undefined;
-    if (_.isPlainObject(bodyObj) && (util.hasValue(bodyObj?.text) || util.hasValue(bodyObj?.value))) {
+    if (
+      util.isPlainObject(bodyObj) &&
+      (util.hasValue(bodyObj?.text) || util.hasValue(bodyObj?.value))
+    ) {
       let {text, value} = bodyObj;
       if (util.hasValue(text) && !util.hasValue(value)) {
-        value = _.isString(text) ? [...text] : _.isArray(text) ? text : [];
+        value = typeof text === 'string' ? [...text] : Array.isArray(text) ? text : [];
         this.log.debug(`Added 'value' property to 'setValue' request body`);
       } else if (!util.hasValue(text) && util.hasValue(value)) {
-        text = _.isArray(value) ? value.join('') : _.isString(value) ? value : '';
+        text = Array.isArray(value) ? value.join('') : typeof value === 'string' ? value : '';
         this.log.debug(`Added 'text' property to 'setValue' request body`);
       }
       return await this.proxyFunc(url, method, {...bodyObj, text, value});
@@ -247,13 +263,20 @@ export class ProtocolConverter {
   private async proxySetFrame(
     url: string,
     method: string,
-    body: HTTPBody
+    body: HTTPBody,
   ): Promise<[ProxyResponse, HTTPBody]> {
     const bodyObj = util.safeJsonParse(body);
-    if (_.has(bodyObj, 'id') && _.isPlainObject(bodyObj.id)) {
+    if (
+      Object.hasOwn(bodyObj ?? {}, 'id') &&
+      util.isPlainObject((bodyObj as Record<string, unknown>).id)
+    ) {
       return await this.proxyFunc(url, method, {
         ...(bodyObj as object),
-        id: duplicateKeys(bodyObj.id as object, MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY),
+        id: duplicateKeys(
+          (bodyObj as Record<string, unknown>).id as object,
+          MJSONWP_ELEMENT_KEY,
+          W3C_ELEMENT_KEY,
+        ),
       });
     }
     return await this.proxyFunc(url, method, body);
@@ -262,14 +285,14 @@ export class ProtocolConverter {
   private async proxyPerformActions(
     url: string,
     method: string,
-    body: HTTPBody
+    body: HTTPBody,
   ): Promise<[ProxyResponse, HTTPBody]> {
     const bodyObj = util.safeJsonParse(body);
-    if (_.isPlainObject(bodyObj)) {
+    if (util.isPlainObject(bodyObj)) {
       return await this.proxyFunc(
         url,
         method,
-        duplicateKeys(bodyObj as object, MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY)
+        duplicateKeys(bodyObj as object, MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY),
       );
     }
     return await this.proxyFunc(url, method, body);
@@ -277,7 +300,7 @@ export class ProtocolConverter {
 
   private async proxyReleaseActions(
     url: string,
-    method: string
+    method: string,
   ): Promise<[ProxyResponse, HTTPBody]> {
     return await this.proxyFunc(url, method);
   }

package/lib/jsonwp-proxy/proxy-request.ts

@@ -1,19 +1,16 @@
 import axios from 'axios';
-import { CancellationError } from 'bluebird';
-import EventEmitter from 'node:events';
-
-const CANCEL_EVENT = 'cancel';
-const FINISH_EVENT = 'finish';
 
 export class ProxyRequest {
   private readonly _requestConfig: axios.RawAxiosRequestConfig;
-  private readonly _ee: EventEmitter;
-  private _resultPromise: Promise<any> | null;
+  private _resultPromise: Promise<axios.AxiosResponse> | null;
+  private _abortController: AbortController | null;
+  private _cancelled: boolean;
 
   constructor(requestConfig: axios.RawAxiosRequestConfig<any>) {
     this._requestConfig = requestConfig;
-    this._ee = new EventEmitter();
     this._resultPromise = null;
+    this._abortController = null;
+    this._cancelled = false;
   }
 
   async execute(): Promise<axios.AxiosResponse> {
@@ -21,32 +18,35 @@ export class ProxyRequest {
       return await this._resultPromise;
     }
 
+    const abortController = new AbortController();
+    this._abortController = abortController;
+    this._cancelled = false;
+
     try {
-      this._resultPromise = Promise.race([
-        this._makeRacingTimer(),
-        this._makeRequest(),
-      ]);
+      this._resultPromise = this._makeRequest(abortController.signal);
       return await this._resultPromise;
     } finally {
-      this._ee.emit(FINISH_EVENT);
-      this._ee.removeAllListeners();
+      this._abortController = null;
     }
   }
 
   cancel(): void {
-    this._ee.emit(CANCEL_EVENT);
-  }
-
-  private async _makeRequest(): Promise<axios.AxiosResponse> {
-    return await axios(this._requestConfig);
+    this._cancelled = true;
+    this._abortController?.abort();
   }
 
-  private async _makeRacingTimer(): Promise<void> {
-    return await new Promise((resolve, reject) => {
-      this._ee.once(FINISH_EVENT, resolve);
-      this._ee.once(CANCEL_EVENT, () => reject(new CancellationError(
-        'The request has been cancelled'
-      )));
-    });
+  private async _makeRequest(signal: AbortSignal): Promise<axios.AxiosResponse> {
+    try {
+      return await axios({
+        ...this._requestConfig,
+        signal,
+      });
+    } catch (err) {
+      if (this._cancelled && axios.isCancel(err)) {
+        // The request was cancelled; do not propagate the error to callers.
+        return await new Promise<axios.AxiosResponse>(() => {});
+      }
+      throw err;
+    }
   }
 }

package/lib/jsonwp-proxy/proxy.ts

@@ -6,7 +6,6 @@ import type {
   ProxyOptions,
   ProxyResponse,
 } from '@appium/types';
-import _ from 'lodash';
 import {logger, util} from '@appium/support';
 import {getSummaryByCode} from '../jsonwp-status/status';
 import {
@@ -19,6 +18,7 @@ import {
 import {isSessionCommand, routeToCommandName} from '../protocol';
 import {MAX_LOG_BODY_LENGTH, DEFAULT_BASE_PATH, PROTOCOLS} from '../constants';
 import {ProtocolConverter} from './protocol-converter';
+import {omit, pick} from '../utils';
 import {formatResponseValue, ensureW3cResponse} from '../protocol/helpers';
 import http from 'node:http';
 import https from 'node:https';
@@ -31,7 +31,7 @@ import type {AxiosError, AxiosResponse, RawAxiosRequestConfig} from 'axios';
 const DEFAULT_LOG = logger.getLogger('WD Proxy');
 const DEFAULT_REQUEST_TIMEOUT = 240000;
 const COMMAND_WITH_SESSION_ID_MATCHER = pathToRegexMatch(
-  '{/*prefix}/session/:sessionId{/*command}'
+  '{/*prefix}/session/:sessionId{/*command}',
 );
 
 const {MJSONWP, W3C} = PROTOCOLS;
@@ -69,8 +69,11 @@ export class JWProxy {
   private readonly _log: AppiumLogger | undefined;
 
   constructor(opts: ProxyOptions = {}) {
-    const filteredOpts = _.pick(opts, ALLOWED_OPTS);
-    const options = _.defaults(_.omit(filteredOpts, 'log'), {
+    const filteredOptsWithoutLog = omit(
+      pick(opts as Record<string, unknown>, ALLOWED_OPTS),
+      'log',
+    ) as Omit<ProxyOptions, 'log'>;
+    const options = {
       scheme: 'http',
       server: 'localhost',
       port: 4444,
@@ -78,7 +81,8 @@ export class JWProxy {
       reqBasePath: DEFAULT_BASE_PATH,
       sessionId: null,
       timeout: DEFAULT_REQUEST_TIMEOUT,
-    }) as ProxyOptions & {
+      ...filteredOptsWithoutLog,
+    } as ProxyOptions & {
       scheme: string;
       server: string;
       port: number;
@@ -88,7 +92,14 @@ export class JWProxy {
       timeout: number;
     };
     options.scheme = options.scheme.toLowerCase();
-    Object.assign(this, options);
+    this.scheme = options.scheme;
+    this.server = options.server;
+    this.port = options.port;
+    this.base = options.base;
+    this.reqBasePath = options.reqBasePath;
+    this.sessionId = options.sessionId;
+    this.timeout = options.timeout;
+    this.headers = options.headers;
 
     this._activeRequests = [];
     this._downstreamProtocol = null;
@@ -147,13 +158,10 @@ export class JWProxy {
   getUrlForProxy(url: string, method?: HTTPMethod): string {
     const parsedUrl = this._parseUrl(url);
     const normalizedPathname = this._toNormalizedPathname(parsedUrl);
-    const commandName = normalizedPathname
-      ? routeToCommandName(normalizedPathname, method)
-      : '';
-    const requiresSessionId =
-      !commandName || (commandName && isSessionCommand(commandName));
+    const commandName = normalizedPathname ? routeToCommandName(normalizedPathname, method) : '';
+    const requiresSessionId = !commandName || (commandName && isSessionCommand(commandName));
     const proxyPrefix = `${this.scheme}://${this.server}:${this.port}${this.base}`;
-    let proxySuffix = normalizedPathname ? `/${_.trimStart(normalizedPathname, '/')}` : '';
+    let proxySuffix = normalizedPathname ? `/${normalizedPathname.replace(/^\/+/, '')}` : '';
     if (parsedUrl.search) {
       proxySuffix += parsedUrl.search;
     }
@@ -161,9 +169,7 @@ export class JWProxy {
       return `${proxyPrefix}${proxySuffix}`;
     }
     if (!this.sessionId) {
-      throw new ReferenceError(
-        `Session ID is not set, but saw a URL that requires it (${url})`
-      );
+      throw new ReferenceError(`Session ID is not set, but saw a URL that requires it (${url})`);
     }
     return `${proxyPrefix}/session/${this.sessionId}${proxySuffix}`;
   }
@@ -174,12 +180,12 @@ export class JWProxy {
   async proxy(
     url: string,
     method: string,
-    body: HTTPBody = null
+    body: HTTPBody = null,
   ): Promise<[ProxyResponse, HTTPBody]> {
     method = method.toUpperCase();
     const newUrl = this.getUrlForProxy(url, method as HTTPMethod);
     const truncateBody = (content: unknown): string =>
-      _.truncate(_.isString(content) ? content : JSON.stringify(content), {
+      util.truncateString(typeof content === 'string' ? content : JSON.stringify(content), {
         length: MAX_LOG_BODY_LENGTH,
       });
     const reqOpts: RawAxiosRequestConfig = {
@@ -206,11 +212,11 @@ export class JWProxy {
           this.log.warn(
             'Invalid body payload (%s): %s',
             (error as Error).message,
-            logger.markSensitive(truncateBody(body))
+            logger.markSensitive(truncateBody(body)),
           );
           throw new Error(
             'Cannot interpret the request body as valid JSON. Check the server log for more details.',
-            {cause: error}
+            {cause: error},
           );
         }
       } else {
@@ -224,7 +230,7 @@ export class JWProxy {
       url || '/',
       method,
       newUrl,
-      reqOpts.data ? logger.markSensitive(truncateBody(reqOpts.data)) : 'no'
+      reqOpts.data ? logger.markSensitive(truncateBody(reqOpts.data)) : 'no',
     );
 
     const throwProxyError = (error: unknown): never => {
@@ -242,7 +248,7 @@ export class JWProxy {
       const {data, status, headers} = await this.request(reqOpts);
       // `data` might be really big
       // Be careful while handling it to avoid memory leaks
-      if (!_.isPlainObject(data)) {
+      if (!util.isPlainObject(data)) {
         // The response should be a valid JSON object
         // If it cannot be coerced to an object then the response is wrong
         throwProxyError(data);
@@ -252,23 +258,14 @@ export class JWProxy {
       const isSessionCreationRequest = url.endsWith('/session') && method === 'POST';
       if (isSessionCreationRequest) {
         if (status === 200) {
-          const value = (data as Record<string, unknown>).value as
-            | Record<string, unknown>
-            | undefined;
-          const raw =
-            (data as Record<string, unknown>).sessionId ?? value?.sessionId;
-          this.sessionId =
-            typeof raw === 'string' ? raw : raw != null ? String(raw) : null;
+          const value = data.value as Record<string, unknown> | undefined;
+          const raw = data.sessionId ?? value?.sessionId;
+          this.sessionId = typeof raw === 'string' ? raw : raw != null ? String(raw) : null;
         }
-        this.downstreamProtocol = this.getProtocolFromResBody(
-          data as Record<string, unknown>
-        ) ?? this.downstreamProtocol;
+        this.downstreamProtocol = this.getProtocolFromResBody(data) ?? this.downstreamProtocol;
         this.log.info(`Determined the downstream protocol as '${this.downstreamProtocol}'`);
       }
-      if (
-        _.has(data, 'status') &&
-        parseInt((data as Record<string, unknown>).status as string, 10) !== 0
-      ) {
+      if (Object.hasOwn(data, 'status') && parseInt(data.status as string, 10) !== 0) {
         throwProxyError(data);
       }
       return [
@@ -288,18 +285,14 @@ export class JWProxy {
           this.log.info(
             util.hasValue(err.response.status)
               ? `Got response with status ${err.response.status}: ${error}`
-              : `Got response with unknown status: ${error}`
+              : `Got response with unknown status: ${error}`,
           );
         }
       } else {
         proxyErrorMsg = `Could not proxy command to the remote server. Original error: ${err.message}`;
         this.log.info(err.message);
       }
-      throw new errors.ProxyRequestError(
-        proxyErrorMsg,
-        err.response?.data,
-        err.response?.status
-      );
+      throw new errors.ProxyRequestError(proxyErrorMsg, err.response?.data, err.response?.status);
     }
   }
 
@@ -307,10 +300,10 @@ export class JWProxy {
    * Detects the downstream protocol from a response body.
    */
   getProtocolFromResBody(resObj: Record<string, unknown>): Protocol | undefined {
-    if (_.isInteger(resObj.status)) {
+    if (Number.isInteger(resObj.status)) {
       return MJSONWP;
     }
-    if (!_.isUndefined(resObj.value)) {
+    if (resObj.value !== undefined) {
       return W3C;
     }
   }
@@ -321,13 +314,11 @@ export class JWProxy {
   async proxyCommand(
     url: string,
     method: HTTPMethod,
-    body: HTTPBody = null
+    body: HTTPBody = null,
   ): Promise<[ProxyResponse, HTTPBody]> {
     const parsedUrl = this._parseUrl(url);
     const normalizedPathname = this._toNormalizedPathname(parsedUrl);
-    const commandName = normalizedPathname
-      ? routeToCommandName(normalizedPathname, method)
-      : '';
+    const commandName = normalizedPathname ? routeToCommandName(normalizedPathname, method) : '';
     if (!commandName) {
       return await this.proxy(url, method, body);
     }
@@ -339,11 +330,7 @@ export class JWProxy {
   /**
    * Executes a WebDriver command and returns the unwrapped `value` field (or throws).
    */
-  async command(
-    url: string,
-    method: HTTPMethod,
-    body: HTTPBody = null
-  ): Promise<HTTPBody> {
+  async command(url: string, method: HTTPMethod, body: HTTPBody = null): Promise<HTTPBody> {
     let response: ProxyResponse;
     let resBodyObj: HTTPBody;
     try {
@@ -363,23 +350,26 @@ export class JWProxy {
       const status = parseInt(resBody.status as string, 10);
       if (!isNaN(status) && status !== 0) {
         let message: unknown = resBody.value;
-        if (_.isPlainObject(message) && _.has(message, 'message')) {
+        if (util.isPlainObject(message) && Object.hasOwn(message, 'message')) {
           message = (message as Record<string, unknown>).message;
         }
-        throw errorFromMJSONWPStatusCode(status, _.isEmpty(message)
-          ? getSummaryByCode(status)
-          : (message as string | {message: string}));
+        throw errorFromMJSONWPStatusCode(
+          status,
+          util.isEmpty(message)
+            ? getSummaryByCode(status)
+            : (message as string | {message: string}),
+        );
       }
     } else if (protocol === W3C) {
       if (response.statusCode < 300) {
         return resBody.value;
       }
-      if (_.isPlainObject(resBody.value) && (resBody.value as Record<string, unknown>).error) {
-        const value = resBody.value as Record<string, unknown>;
+      if (util.isPlainObject(resBody.value) && resBody.value.error) {
+        const value = resBody.value;
         throw errorFromW3CJsonCode(
           value.error as string,
           (value.message as string) ?? '',
-          value.stacktrace as string | undefined
+          value.stacktrace as string | undefined,
         );
       }
     } else if (response.statusCode === 200) {
@@ -387,9 +377,9 @@ export class JWProxy {
     }
     throw new errors.UnknownError(
       `Did not know what to do with response code '${response.statusCode}' ` +
-        `and response body '${_.truncate(JSON.stringify(resBodyObj), {
+        `and response body '${util.truncateString(JSON.stringify(resBodyObj), {
           length: 300,
-        })}'`
+        })}'`,
     );
   }
 
@@ -414,26 +404,28 @@ export class JWProxy {
       const [response, body] = await this.proxyCommand(
         req.originalUrl,
         req.method as HTTPMethod,
-        req.body
+        req.body,
       );
       statusCode = response.statusCode;
       resBodyObj = body;
     } catch (err: unknown) {
       [statusCode, resBodyObj] = getResponseForW3CError(
-        isErrorType(err, errors.ProxyRequestError) ? (err as InstanceType<typeof errors.ProxyRequestError>).getActualError() : err
+        isErrorType(err, errors.ProxyRequestError)
+          ? (err as InstanceType<typeof errors.ProxyRequestError>).getActualError()
+          : err,
       );
     }
     res.setHeader('content-type', 'application/json; charset=utf-8');
-    if (!_.isPlainObject(resBodyObj)) {
+    if (!util.isPlainObject(resBodyObj)) {
       const error = new errors.UnknownError(
         `The downstream server response with the status code ${statusCode} is not a valid JSON object: ` +
-          _.truncate(`${resBodyObj}`, {length: 300})
+          util.truncateString(`${resBodyObj}`, {length: 300}),
       );
       [statusCode, resBodyObj] = getResponseForW3CError(error);
     }
 
     const resBody = resBodyObj as Record<string, unknown>;
-    if (_.has(resBody, 'sessionId')) {
+    if (Object.hasOwn(resBody, 'sessionId')) {
       const reqSessionId = this.getSessionIdFromUrl(req.originalUrl);
       if (reqSessionId) {
         this.log.info(`Replacing sessionId ${resBody.sessionId} with ${reqSessionId}`);
@@ -459,7 +451,10 @@ export class JWProxy {
     try {
       return await req.execute();
     } finally {
-      _.pull(this._activeRequests, req);
+      const reqIndex = this._activeRequests.indexOf(req);
+      if (reqIndex >= 0) {
+        this._activeRequests.splice(reqIndex, 1);
+      }
     }
   }
 
@@ -467,8 +462,8 @@ export class JWProxy {
     // eslint-disable-next-line n/no-deprecated-api -- we need relative URL support
     const parsedUrl = nodeUrl.parse(url || '/');
     if (
-      _.isNil(parsedUrl.href) ||
-      _.isNil(parsedUrl.pathname) ||
+      parsedUrl.href == null ||
+      parsedUrl.pathname == null ||
       (parsedUrl.protocol && !['http:', 'https:'].includes(parsedUrl.protocol))
     ) {
       throw new Error(`Did not know how to proxy the url '${url}'`);
@@ -477,7 +472,7 @@ export class JWProxy {
   }
 
   private _toNormalizedPathname(parsedUrl: nodeUrl.UrlWithStringQuery): string {
-    if (!_.isString(parsedUrl.pathname)) {
+    if (typeof parsedUrl.pathname !== 'string') {
       return '';
     }
     let pathname =
@@ -488,20 +483,24 @@ export class JWProxy {
     // This is needed for the backward compatibility
     // if drivers don't set reqBasePath properly
     if (!this.reqBasePath) {
-      if (match && match.params && _.isArray((match.params as Record<string, unknown>).prefix)) {
+      if (
+        match &&
+        match.params &&
+        Array.isArray((match.params as Record<string, unknown>).prefix)
+      ) {
         pathname = pathname.replace(
           `/${((match.params as Record<string, unknown>).prefix as string[]).join('/')}`,
-          ''
+          '',
         );
-      } else if (_.startsWith(pathname, '/wd/hub')) {
+      } else if (pathname.startsWith('/wd/hub')) {
         pathname = pathname.replace('/wd/hub', '');
       }
     }
     let result = pathname;
     if (match && match.params) {
       const command = (match.params as Record<string, unknown>).command;
-      result = _.isArray(command) ? `/${(command as string[]).join('/')}` : '';
+      result = Array.isArray(command) ? `/${(command as string[]).join('/')}` : '';
     }
-    return _.trimEnd(result, '/');
+    return result.replace(/\/+$/, '');
   }
 }