@appium/base-driver 10.5.2 → 10.7.0

package/lib/protocol/protocol.ts

@@ -1,4 +1,3 @@
-import _ from 'lodash';
 import {util, logger} from '@appium/support';
 import {validators} from './validators';
 import {
@@ -10,13 +9,20 @@ import {
   BadParametersError,
 } from './errors';
 import {METHOD_MAP, NO_SESSION_ID_COMMANDS} from './routes';
-import B from 'bluebird';
 import {formatResponseValue, ensureW3cResponse} from './helpers';
 import {MAX_LOG_BODY_LENGTH, PROTOCOLS, DEFAULT_BASE_PATH} from '../constants';
 import {isW3cCaps} from '../helpers/capabilities';
 import {log} from '../basedriver/logger';
+import {omitKeys} from '../utils';
 import {generateDriverLogPrefix} from '../basedriver/helpers';
-import type {Core, AppiumLogger, PayloadParams, MethodMap, Driver, DriverMethodDef} from '@appium/types';
+import type {
+  Core,
+  AppiumLogger,
+  PayloadParams,
+  MethodMap,
+  Driver,
+  DriverMethodDef,
+} from '@appium/types';
 import type {BaseDriver} from '../basedriver/driver';
 import type {Request, Response, Application} from 'express';
 import type {MultidimensionalReadonlyArray} from 'type-fest';
@@ -35,7 +41,7 @@ export const deprecatedCommandsLogged: Set<string> = new Set();
  * @param createSessionArgs - Arguments passed to the createSession command
  */
 export function determineProtocol(createSessionArgs: any[]): keyof typeof PROTOCOLS {
-  return _.some(createSessionArgs, isW3cCaps) ? PROTOCOLS.W3C : PROTOCOLS.MJSONWP;
+  return createSessionArgs.some(isW3cCaps) ? PROTOCOLS.W3C : PROTOCOLS.MJSONWP;
 }
 
 /**
@@ -55,10 +61,10 @@ export function getSessionId(driver: Core<any>, req: Request): string | undefine
     const sessionId = req.params.sessionId[0];
     getLogger(driver, sessionId).warn(
       `Received malformed sessionId as array from the route: ${req.originalUrl}. ` +
-      `This indicates the route definition issue. The route should start with '/session/:sessionId' (named parameter) ` +
-      `instead of '/session/*sessionId' (wildcard). ` +
-      `Using the first element as session id: ${sessionId}. ` +
-      `Please fix the route definition to prevent this error.`
+        `This indicates the route definition issue. The route should start with '/session/:sessionId' (named parameter) ` +
+        `instead of '/session/*sessionId' (wildcard). ` +
+        `Using the first element as session id: ${sessionId}. ` +
+        `Please fix the route definition to prevent this error.`,
     );
     // This is to not log the message multiple times.
     req.params.sessionId = sessionId;
@@ -72,7 +78,7 @@ export function getSessionId(driver: Core<any>, req: Request): string | undefine
  * @returns Whether the command requires a session id in the URL
  */
 export function isSessionCommand(command: string): boolean {
-  return !_.includes(NO_SESSION_ID_COMMANDS, command);
+  return !NO_SESSION_ID_COMMANDS.includes(command);
 }
 
 /**
@@ -84,25 +90,24 @@ export function isSessionCommand(command: string): boolean {
 export function checkParams(
   paramSpec: PayloadParams,
   args: Record<string, any>,
-  protocol?: keyof typeof PROTOCOLS
+  protocol?: keyof typeof PROTOCOLS,
 ): Record<string, any> {
   let requiredParams: string[][] = [];
   let optionalParams: string[] = [];
-  const actualParamNames: string[] = _.keys(args);
+  const actualParamNames: string[] = Object.keys(args);
 
   if (paramSpec.required) {
     // we might have an array of parameters,
     // or an array of arrays of parameters, so standardize
-    requiredParams = _.cloneDeep(
+    requiredParams = structuredClone(
       (hasMultipleRequiredParamSets(paramSpec.required)
         ? paramSpec.required
-        : [paramSpec.required]
-      ) as string[][]
+        : [paramSpec.required]) as string[][],
     );
   }
   // optional parameters are just an array
   if (paramSpec.optional) {
-    optionalParams = _.cloneDeep(paramSpec.optional as string[]);
+    optionalParams = structuredClone(paramSpec.optional as string[]);
   }
 
   // If a function was provided as the 'validate' key, it will here be called with
@@ -112,49 +117,57 @@ export function checkParams(
   if (paramSpec.validate) {
     const message = paramSpec.validate(args, protocol ?? PROTOCOLS.W3C);
     if (message) {
-      throw new errors.InvalidArgumentError(_.isString(message) ? message : undefined);
+      throw new errors.InvalidArgumentError(typeof message === 'string' ? message : undefined);
     }
   }
 
   // some clients pass in the session id in the params
-  if (!_.includes(optionalParams, 'sessionId')) {
+  if (!optionalParams.includes('sessionId')) {
     optionalParams.push('sessionId');
   }
   // some clients pass in an element id in the params
-  if (!_.includes(optionalParams, 'id')) {
+  if (!optionalParams.includes('id')) {
     optionalParams.push('id');
   }
 
-  if (_.isEmpty(requiredParams)) {
+  if (util.isEmpty(requiredParams)) {
     // if we don't have any required parameters, then just filter out unknown ones
-    return pickKnownParams(args, _.difference(actualParamNames, optionalParams));
+    return pickKnownParams(
+      args,
+      actualParamNames.filter((name) => !optionalParams.includes(name)),
+    );
   }
 
   // go through the required parameters and check against our arguments
   let matchedReqParamSet: string[] = [];
   for (const requiredParamsSet of requiredParams) {
-    if (!_.isArray(requiredParamsSet)) {
+    if (!Array.isArray(requiredParamsSet)) {
       throw new Error(
         `The required parameter set item ${JSON.stringify(requiredParamsSet)} ` +
-        `in ${JSON.stringify(paramSpec)} is not an array. ` +
-        `This is a bug in the method map definition.`
+          `in ${JSON.stringify(paramSpec)} is not an array. ` +
+          `This is a bug in the method map definition.`,
       );
     }
-    if (_.isEmpty(_.difference(requiredParamsSet, actualParamNames))) {
+    if (requiredParamsSet.every((name) => actualParamNames.includes(name))) {
       return pickKnownParams(
         args,
-        _.difference(actualParamNames, requiredParamsSet, optionalParams)
+        actualParamNames.filter(
+          (name) => !requiredParamsSet.includes(name) && !optionalParams.includes(name),
+        ),
       );
     }
-    if (!_.isEmpty(requiredParamsSet) && _.isEmpty(matchedReqParamSet)) {
+    if (!util.isEmpty(requiredParamsSet) && util.isEmpty(matchedReqParamSet)) {
       matchedReqParamSet = requiredParamsSet;
     }
   }
-  throw new BadParametersError({
-    ...paramSpec,
-    required: matchedReqParamSet,
-    optional: optionalParams,
-  }, actualParamNames);
+  throw new BadParametersError(
+    {
+      ...paramSpec,
+      required: matchedReqParamSet,
+      optional: optionalParams,
+    },
+    actualParamNames,
+  );
 }
 
 /**
@@ -163,12 +176,16 @@ export function checkParams(
  * @param jsonObj - Parsed JSON request body
  * @param payloadParams - Route payload definition (required/optional/makeArgs)
  */
-export function makeArgs(requestParams: PayloadParams, jsonObj: any, payloadParams: PayloadParams): any[] {
+export function makeArgs(
+  requestParams: Record<string, string | string[] | undefined>,
+  jsonObj: any,
+  payloadParams: PayloadParams,
+): any[] {
   // We want to pass the "url" parameters to the commands in reverse order
   // since the command will sometimes want to ignore, say, the sessionId.
   // This has the effect of putting sessionId last, which means in JS we can
   // omit it from the function signature if we're not going to use it.
-  const urlParams = _.keys(requestParams).reverse();
+  const urlParams = Object.keys(requestParams).reverse();
 
   // In the simple case, the required parameters are a basic array in
   // payloadParams.required, so start there. It's possible that there are
@@ -180,9 +197,9 @@ export function makeArgs(requestParams: PayloadParams, jsonObj: any, payloadPara
     // array of arrays in payloadParams.required, so loop through each set and
     // pick the one that matches which JSON params were actually sent. We've
     // already been through validation so we're guaranteed to find a match.
-    const keys = _.keys(jsonObj);
+    const keys = Object.keys(jsonObj);
     for (const params of payloadParams.required) {
-      if (_.without(params, ...keys).length === 0) {
+      if (params.filter((p) => !keys.includes(p)).length === 0) {
         requiredParams = params;
         break;
       }
@@ -191,7 +208,7 @@ export function makeArgs(requestParams: PayloadParams, jsonObj: any, payloadPara
 
   // Now we construct our list of arguments which will be passed to the command
   let args;
-  if (_.isFunction(payloadParams.makeArgs)) {
+  if (typeof payloadParams.makeArgs === 'function') {
     // In the route spec, a particular route might define a 'makeArgs' function
     // if it wants full control over how to turn JSON parameters into command
     // arguments. So we pass it the JSON parameters and it returns an array
@@ -202,9 +219,9 @@ export function makeArgs(requestParams: PayloadParams, jsonObj: any, payloadPara
   } else {
     // Otherwise, collect all the required and optional params and flatten them
     // into an argument array
-    args = _.flatten(requiredParams).map((p) => jsonObj[p]);
+    args = (requiredParams ?? []).flat().map((p) => jsonObj[p]);
     if (payloadParams.optional) {
-      args = args.concat(_.flatten(payloadParams.optional).map((p) => jsonObj[p]));
+      args = args.concat((payloadParams.optional ?? []).flat().map((p) => jsonObj[p]));
     }
   }
   // Finally, get our url params (session id, element id, etc...) on the end of
@@ -222,17 +239,17 @@ export function validateExecuteMethodParams(params: any[], paramSpec?: PayloadPa
   // the w3c protocol will give us an array of arguments to apply to a javascript function.
   // that's not what we're doing. we're going to look for a JS object as the first arg, so we
   // can perform validation on it. we'll ignore everything else.
-  if (!params || !_.isArray(params) || params.length > 1) {
+  if (!params || !Array.isArray(params) || params.length > 1) {
     throw new errors.InvalidArgumentError(
       `Did not get correct format of arguments for execute method. Expected zero or one ` +
-        `arguments to execute script and instead received: ${JSON.stringify(params)}`
+        `arguments to execute script and instead received: ${JSON.stringify(params)}`,
     );
   }
   const args: Record<string, any> = params[0] ?? {};
-  if (!_.isPlainObject(args)) {
+  if (!util.isPlainObject(args)) {
     throw new errors.InvalidArgumentError(
       `Did not receive an appropriate execute method parameters object. It needs to be ` +
-        `deserializable as a plain JS object`
+        `deserializable as a plain JS object`,
     );
   }
   const specToUse = {
@@ -265,18 +282,11 @@ export function routeConfiguringFunction(driver: Core<any>): RouteConfiguringFun
     driver.basePath = basePath;
 
     const allMethods: MethodMap<Driver> = {...METHOD_MAP, ...extraMethodMap};
-    for (const [path, methods] of _.toPairs(allMethods)) {
-      for (const [method, spec] of _.toPairs(methods)) {
+    for (const [path, methods] of Object.entries(allMethods)) {
+      for (const [method, spec] of Object.entries(methods)) {
         const isSessCommand = spec.command ? isSessionCommand(spec.command) : false;
         // set up the express route handler
-        buildHandler(
-          app,
-          method,
-          `${basePath}${path}`,
-          spec,
-          driver,
-          isSessCommand
-        );
+        buildHandler(app, method, `${basePath}${path}`, spec, driver, isSessCommand);
       }
     }
   };
@@ -310,10 +320,14 @@ export function driverShouldDoJwpProxy(driver: Core<any>, req: Request, command:
   return true;
 }
 
-function extractProtocol(driver: Core<any>, sessionId: string | null = null): keyof typeof PROTOCOLS {
-  const dstDriver = _.isFunction(driver.driverForSession) && sessionId
-    ? driver.driverForSession(sessionId)
-    : driver;
+function extractProtocol(
+  driver: Core<any>,
+  sessionId: string | null = null,
+): keyof typeof PROTOCOLS {
+  const dstDriver =
+    typeof driver.driverForSession === 'function' && sessionId
+      ? driver.driverForSession(sessionId)
+      : driver;
   if (dstDriver === driver) {
     // Shortcircuit if the driver instance is not an umbrella driver
     // or it is Fake driver instance, where `driver.driverForSession`
@@ -327,10 +341,10 @@ function extractProtocol(driver: Core<any>, sessionId: string | null = null): ke
 
 function getLogger(driver: Core<any>, sessionId: string | null = null): AppiumLogger {
   const dstDriver =
-    sessionId && _.isFunction(driver.driverForSession)
-      ? driver.driverForSession(sessionId) ?? driver
+    sessionId && typeof driver.driverForSession === 'function'
+      ? (driver.driverForSession(sessionId) ?? driver)
       : driver;
-  if (_.isFunction(dstDriver.log?.info)) {
+  if (typeof dstDriver.log?.info === 'function') {
     return dstDriver.log;
   }
 
@@ -338,14 +352,15 @@ function getLogger(driver: Core<any>, sessionId: string | null = null): AppiumLo
   return logger.getLogger(logPrefix);
 }
 
-function wrapParams<T>(paramSets, jsonObj: T): T | Record<string, T> {
+function wrapParams<T>(paramSets: PayloadParams, jsonObj: T): T | Record<string, T> {
   /* There are commands like performTouch which take a single parameter (primitive type or array).
    * Some drivers choose to pass this parameter as a value (eg. [action1, action2...]) while others to
    * wrap it within an object(eg' {gesture:  [action1, action2...]}), which makes it hard to validate.
    * The wrap option in the spec enforce wrapping before validation, so that all params are wrapped at
    * the time they are validated and later passed to the commands.
    */
-  return (_.isArray(jsonObj) || !_.isObject(jsonObj)) && paramSets.wrap
+  return (Array.isArray(jsonObj) || typeof jsonObj !== 'object' || jsonObj === null) &&
+    paramSets.wrap
     ? {[paramSets.wrap]: jsonObj}
     : jsonObj;
 }
@@ -354,25 +369,25 @@ function unwrapParams<T>(paramSets: PayloadParams, jsonObj: T): T | Record<strin
   /* There are commands like setNetworkConnection which send parameters wrapped inside a key such as
    * "parameters". This function unwraps them (eg. {"parameters": {"type": 1}} becomes {"type": 1}).
    */
-  return _.isObject(jsonObj) && paramSets.unwrap && jsonObj[paramSets.unwrap]
-    ? jsonObj[paramSets.unwrap]
-    : jsonObj;
+  const unwrapped =
+    typeof jsonObj === 'object' && jsonObj !== null && paramSets.unwrap
+      ? (jsonObj as Record<string, T>)[paramSets.unwrap]
+      : undefined;
+  return unwrapped !== undefined ? unwrapped : jsonObj;
 }
 
-
 function hasMultipleRequiredParamSets(
-  required: ReadonlyArray<string> | MultidimensionalReadonlyArray<string, 2> | undefined
+  required: ReadonlyArray<string> | MultidimensionalReadonlyArray<string, 2> | undefined,
 ): required is MultidimensionalReadonlyArray<string, 2> {
-  //@ts-expect-error Needed to convince lodash typechecks
-  return Boolean(required && _.isArray(_.first(required)));
+  return Boolean(required && Array.isArray(required?.[0]));
 }
 
 function pickKnownParams(args: Record<string, any>, unknownNames: string[]): Record<string, any> {
-  if (_.isEmpty(unknownNames)) {
+  if (util.isEmpty(unknownNames)) {
     return args;
   }
   log.info(`The following arguments are not known and will be ignored: ${unknownNames}`);
-  return _.pickBy(args, (v, k) => !unknownNames.includes(k));
+  return omitKeys(args, unknownNames);
 }
 
 function buildHandler(
@@ -381,7 +396,7 @@ function buildHandler(
   path: string,
   spec: DriverMethodDef<Driver>,
   driver: Core<any>,
-  isSessCmd: boolean
+  isSessCmd: boolean,
 ): void {
   const asyncHandler = async (req: Request, res: Response) => {
     let jsonObj = req.body;
@@ -398,7 +413,7 @@ function buildHandler(
         getLogger(driver, sessionId).warn(
           `The ${method} ${path} endpoint has been deprecated and will be removed in a future ` +
             `version of Appium or your driver/plugin. Please use a different endpoint or contact the ` +
-            `driver/plugin author to add explicit support for the endpoint before it is removed`
+            `driver/plugin author to add explicit support for the endpoint before it is removed`,
         );
       }
 
@@ -417,9 +432,15 @@ function buildHandler(
       // commands and generally would not want that command to be proxied instead of handled by the
       // plugin)
       let didPluginOverrideProxy = false;
-      if (isSessCmd && !spec.neverProxy && spec.command && driverShouldDoJwpProxy(driver, req, spec.command)) {
+      if (
+        isSessCmd &&
+        !spec.neverProxy &&
+        spec.command &&
+        driverShouldDoJwpProxy(driver, req, spec.command)
+      ) {
         if (
-          !('pluginsToHandleCmd' in driver) || !_.isFunction(driver.pluginsToHandleCmd) ||
+          !('pluginsToHandleCmd' in driver) ||
+          typeof driver.pluginsToHandleCmd !== 'function' ||
           driver.pluginsToHandleCmd(spec.command, sessionId).length === 0
         ) {
           await doJwpProxy(driver as BaseDriver<any>, req, res);
@@ -428,7 +449,7 @@ function buildHandler(
         getLogger(driver, sessionId).debug(
           `Would have proxied ` +
             `command directly, but a plugin exists which might require its value, so will let ` +
-            `its value be collected internally and made part of plugin chain`
+            `its value be collected internally and made part of plugin chain`,
         );
         didPluginOverrideProxy = true;
       }
@@ -453,7 +474,7 @@ function buildHandler(
         // try to determine protocol by session creation args, so we can throw a
         // properly formatted error if arguments validation fails
         currentProtocol = determineProtocol(
-          makeArgs(req.params, jsonObj, spec.payloadParams || {})
+          makeArgs(req.params, jsonObj, spec.payloadParams || {}),
         );
       }
 
@@ -467,15 +488,21 @@ function buildHandler(
       const args = makeArgs(req.params, jsonObj, spec.payloadParams || {});
       let driverRes: any;
       // validate command args according to MJSONWP
-      if (validators[spec.command]) {
-        validators[spec.command](...args);
+      const validator = (
+        validators as Record<string, ((...validatorArgs: any[]) => void) | undefined>
+      )[spec.command];
+      if (validator) {
+        validator(...args);
       }
 
       // run the driver command wrapped inside the argument validators
       getLogger(driver, sessionId).debug(
         `Calling %s.%s() with args: %s`,
-        driver.constructor.name, spec.command,
-        logger.markSensitive(_.truncate(JSON.stringify(args), {length: MAX_LOG_BODY_LENGTH}))
+        driver.constructor.name,
+        spec.command,
+        logger.markSensitive(
+          util.truncateString(JSON.stringify(args), {length: MAX_LOG_BODY_LENGTH}),
+        ),
       );
 
       if (didPluginOverrideProxy) {
@@ -492,8 +519,9 @@ function buildHandler(
 
       // If `executeCommand` was overridden and the method returns an object
       // with a protocol and value/error property, re-assign the protocol
-      if (_.isPlainObject(driverRes) && _.has(driverRes, 'protocol')) {
-        currentProtocol = driverRes.protocol || currentProtocol;
+      if (util.isPlainObject(driverRes) && Object.hasOwn(driverRes, 'protocol')) {
+        currentProtocol =
+          (driverRes as {protocol?: keyof typeof PROTOCOLS}).protocol || currentProtocol;
         if (driverRes.error) {
           throw driverRes.error;
         }
@@ -504,7 +532,7 @@ function buildHandler(
       if (spec.command === CREATE_SESSION_COMMAND) {
         newSessionId = driverRes[0];
         getLogger(driver, newSessionId).debug(
-          `Cached the protocol value '${currentProtocol}' for the new session ${newSessionId}`
+          `Cached the protocol value '${currentProtocol}' for the new session ${newSessionId}`,
         );
         if (currentProtocol === PROTOCOLS.MJSONWP) {
           driverRes = driverRes[1];
@@ -520,9 +548,9 @@ function buildHandler(
       // delete should not return anything even if successful
       if (spec.command === DELETE_SESSION_COMMAND) {
         getLogger(driver, sessionId).debug(
-          `Received response: ${_.truncate(JSON.stringify(driverRes), {
+          `Received response: ${util.truncateString(JSON.stringify(driverRes), {
             length: MAX_LOG_BODY_LENGTH,
-          })}`
+          })}`,
         );
         getLogger(driver, sessionId).debug('But deleting session, so not returning');
         driverRes = null;
@@ -536,11 +564,11 @@ function buildHandler(
           parseInt(driverRes.status, 10) !== 0
         ) {
           throw errorFromMJSONWPStatusCode(driverRes.status, driverRes.value);
-        } else if (_.isPlainObject(driverRes.value) && driverRes.value.error) {
+        } else if (util.isPlainObject(driverRes.value) && driverRes.value.error) {
           throw errorFromW3CJsonCode(
             driverRes.value.error,
             driverRes.value.message,
-            driverRes.value.stacktrace
+            driverRes.value.stacktrace,
           );
         }
       }
@@ -548,38 +576,48 @@ function buildHandler(
       httpResBody.value = driverRes;
       getLogger(driver, sessionId || newSessionId).debug(
         `Responding ` +
-          `to client with driver.${spec.command}() result: ${_.truncate(JSON.stringify(driverRes), {
-            length: MAX_LOG_BODY_LENGTH,
-          })}`
+          `to client with driver.${spec.command}() result: ${util.truncateString(
+            JSON.stringify(driverRes),
+            {
+              length: MAX_LOG_BODY_LENGTH,
+            },
+          )}`,
       );
     } catch (err) {
       // if anything goes wrong, figure out what our response should be
       // based on the type of error that we encountered
-      let actualErr;
-      if (err instanceof Error || (_.has(err, 'stack') && _.has(err, 'message'))) {
+      let actualErr: Error;
+      if (err instanceof Error) {
         actualErr = err;
+      } else if (
+        typeof err === 'object' &&
+        err !== null &&
+        Object.hasOwn(err, 'stack') &&
+        Object.hasOwn(err, 'message')
+      ) {
+        actualErr = err as Error;
       } else {
         getLogger(driver, sessionId || newSessionId).warn(
           'The thrown error object does not seem to be a valid instance of the Error class. This ' +
-            'might be a genuine bug of a driver or a plugin.'
+            'might be a genuine bug of a driver or a plugin.',
         );
         actualErr = new Error(`${err ?? 'unknown'}`);
       }
 
-      currentProtocol =
-        currentProtocol || extractProtocol(driver, sessionId || newSessionId);
+      currentProtocol = currentProtocol || extractProtocol(driver, sessionId || newSessionId);
 
-      let errMsg = err.stacktrace || err.stack;
-      if (!_.includes(errMsg, err.message)) {
+      const stacktrace = (err as {stacktrace?: string}).stacktrace;
+      let errMsg = stacktrace || actualErr.stack || '';
+      if (!errMsg.includes(actualErr.message)) {
         // if the message has more information, add it. but often the message
         // is the first part of the stack trace
-        errMsg = `${err.message}${errMsg ? '\n' + errMsg : ''}`;
+        errMsg = `${actualErr.message}${errMsg ? '\n' + errMsg : ''}`;
       }
       if (isErrorType(err, errors.ProxyRequestError)) {
         actualErr = err.getActualError();
       } else {
         getLogger(driver, sessionId || newSessionId).debug(
-          `Encountered internal error running command: ${errMsg}`
+          `Encountered internal error running command: ${errMsg}`,
         );
       }
 
@@ -587,8 +625,9 @@ function buildHandler(
     }
 
     // decode the response, which is either a string or json
-    if (_.isString(httpResBody)) {
-      res.status(httpStatus)
+    if (typeof httpResBody === 'string') {
+      res
+        .status(httpStatus)
         .setHeader('content-type', 'application/json; charset=utf-8')
         .send(httpResBody);
     } else {
@@ -599,16 +638,17 @@ function buildHandler(
     }
   };
   // add the method to the app
-  app[method.toLowerCase()](path, (req, res) => {
-    B.resolve(asyncHandler(req, res)).done();
+  const registerRoute = (
+    app as Application & Record<string, (routePath: string, ...handlers: any[]) => void>
+  )[method.toLowerCase()].bind(app);
+  registerRoute(path, (req: Request, res: Response) => {
+    void asyncHandler(req, res);
   });
 }
 
 async function doJwpProxy(driver: BaseDriver<any>, req: Request, res: Response): Promise<void> {
   const sessionId = getSessionId(driver, req) as string;
-  getLogger(driver, sessionId).info(
-    'Driver proxy active, passing request on via HTTP proxy'
-  );
+  getLogger(driver, sessionId).info('Driver proxy active, passing request on via HTTP proxy');
 
   // check that the inner driver has a proxy function
   if (!driver.canProxy(sessionId)) {
@@ -619,8 +659,10 @@ async function doJwpProxy(driver: BaseDriver<any>, req: Request, res: Response):
   } catch (err) {
     if (isErrorType(err, errors.ProxyRequestError)) {
       throw err;
-    } else {
+    }
+    if (err instanceof Error) {
       throw new Error(`Could not proxy. Proxy error: ${err.message}`, {cause: err});
     }
+    throw new Error(`Could not proxy. Proxy error: ${String(err)}`, {cause: err});
   }
 }

package/lib/protocol/routes.ts

@@ -1,5 +1,5 @@
 import type {Driver, DriverMethodDef, HTTPMethod, MethodMap} from '@appium/types';
-import _ from 'lodash';
+import {util} from '@appium/support';
 import {DEFAULT_BASE_PATH} from '../constants';
 import {match} from 'path-to-regexp';
 import {LRUCache} from 'lru-cache';
@@ -14,7 +14,6 @@ const COMMAND_NAMES_CACHE = new LRUCache<string, string>({
  * `optional`.
  */
 export const METHOD_MAP = {
-
   // #region W3C WebDriver
   // https://www.w3.org/TR/webdriver2/
   '/session': {
@@ -244,8 +243,8 @@ export const METHOD_MAP = {
           'shrinkToFit',
           'pageRanges',
         ],
-      }
-    }
+      },
+    },
   },
   // #endregion
 
@@ -274,7 +273,7 @@ export const METHOD_MAP = {
     GET: {command: 'getOrientation'},
     POST: {
       command: 'setOrientation',
-      payloadParams: {required: ['orientation']}
+      payloadParams: {required: ['orientation']},
     },
   },
   '/session/:sessionId/location': {
@@ -318,7 +317,7 @@ export const METHOD_MAP = {
     GET: {command: 'getAppiumSessions'},
   },
   '/session/:sessionId/appium/capabilities': {
-    GET: {command: 'getAppiumSessionCapabilities'}
+    GET: {command: 'getAppiumSessionCapabilities'},
   },
   '/session/:sessionId/appium/settings': {
     POST: {command: 'updateSettings', payloadParams: {required: ['settings']}},
@@ -579,9 +578,9 @@ export const METHOD_MAP = {
 } as const satisfies MethodMap<Driver>;
 
 // driver command names
-export const ALL_COMMANDS = _.flatMap(_.values(METHOD_MAP).map(_.values))
-  .filter((m) => Boolean(m.command))
-  .map((m) => m.command);
+export const ALL_COMMANDS = Object.values(METHOD_MAP)
+  .flatMap((methods) => Object.values(methods) as Array<{command?: string}>)
+  .flatMap((m) => (m.command ? [m.command] : []));
 
 /**
  * Resolve a WebDriver URL path and HTTP method to a driver command name from {@link METHOD_MAP}.
@@ -592,13 +591,13 @@ export const ALL_COMMANDS = _.flatMap(_.values(METHOD_MAP).map(_.values))
 export function routeToCommandName(
   endpoint: string,
   method?: HTTPMethod,
-  basePath?: string
+  basePath?: string,
 ): string | undefined {
   const resolvedBasePath = basePath ?? DEFAULT_BASE_PATH;
   let normalizedEndpoint = resolvedBasePath
-    ? endpoint.replace(new RegExp(`^${_.escapeRegExp(resolvedBasePath)}`), '')
+    ? endpoint.replace(new RegExp(`^${util.escapeRegExp(resolvedBasePath)}`), '')
     : endpoint;
-  normalizedEndpoint = `${_.startsWith(normalizedEndpoint, '/') ? '' : '/'}${normalizedEndpoint}`;
+  normalizedEndpoint = `${normalizedEndpoint.startsWith('/') ? '' : '/'}${normalizedEndpoint}`;
   let normalizedPathname: string;
   try {
     // we could use any prefix there as we anyway need to only extract the pathname
@@ -608,7 +607,7 @@ export function routeToCommandName(
     throw new Error(`'${endpoint}' cannot be translated to a command name: ${msg}`, {cause: err});
   }
 
-  const normalizedMethod = _.toUpper(method ?? '');
+  const normalizedMethod = (method ?? '').toUpperCase();
   const cacheKey = toCommandNameCacheKey(normalizedPathname, normalizedMethod);
   const cached = COMMAND_NAMES_CACHE.get(cacheKey);
   if (cached !== undefined) {
@@ -620,13 +619,14 @@ export function routeToCommandName(
     possiblePathnames.push(`/session/any-session-id${normalizedPathname}`);
   }
   possiblePathnames.push(normalizedPathname);
-  for (const [routePath, routeSpec] of _.toPairs(METHOD_MAP)) {
+  for (const [routePath, routeSpec] of Object.entries(METHOD_MAP)) {
     const routeMatcher = match(routePath);
     if (possiblePathnames.some((pp) => routeMatcher(pp))) {
       const spec = routeSpec as Record<string, DriverMethodDef<Driver>>;
-      const commandForAnyMethod = () =>
-        _.first(_.keys(spec).map((key) => spec[key]?.command));
-      const commandName = normalizedMethod ? spec[normalizedMethod]?.command : commandForAnyMethod();
+      const commandForAnyMethod = () => Object.keys(spec).map((key) => spec[key]?.command)[0];
+      const commandName = normalizedMethod
+        ? spec[normalizedMethod]?.command
+        : commandForAnyMethod();
       if (commandName) {
         COMMAND_NAMES_CACHE.set(cacheKey, commandName);
         return commandName;