@appium/base-driver 10.5.2 → 10.7.0

package/lib/basedriver/validation.ts

@@ -1,6 +1,6 @@
 import type {Constraint} from '@appium/types';
+import {util} from '@appium/support';
 import {log} from './logger';
-import _ from 'lodash';
 
 export class Validator {
   private readonly _validators: Record<
@@ -8,27 +8,27 @@ export class Validator {
     (value: any, options?: any, key?: string) => string | null
   > = {
     isString: (value: any, options?: any): string | null => {
-      if (_.isUndefined(value) || _.isNil(options)) {
+      if (value === undefined || options == null) {
         return null;
       }
 
-      if (_.isString(value)) {
+      if (typeof value === 'string') {
         return options ? null : 'must not be of type string';
       }
 
       return options ? 'must be of type string' : null;
     },
     isNumber: (value: any, options?: any): string | null => {
-      if (_.isUndefined(value) || _.isNil(options)) {
+      if (value === undefined || options == null) {
         return null;
       }
 
-      if (_.isNumber(value)) {
+      if (typeof value === 'number') {
         return options ? null : 'must not be of type number';
       }
 
       // allow a string value
-      if (options && _.isString(value) && !isNaN(Number(value))) {
+      if (options && typeof value === 'string' && !isNaN(Number(value))) {
         log.warn('Number capability passed in as string. Functionality may be compromised.');
         return null;
       }
@@ -36,97 +36,105 @@ export class Validator {
       return options ? 'must be of type number' : null;
     },
     isBoolean: (value: any, options?: any): string | null => {
-      if (_.isUndefined(value) || _.isNil(options)) {
+      if (value === undefined || options == null) {
         return null;
       }
 
-      if (_.isBoolean(value)) {
+      if (typeof value === 'boolean') {
         return options ? null : 'must not be of type boolean';
       }
 
       // allow a string value
-      if (options && _.isString(value) && ['true', 'false', ''].includes(value)) {
+      if (options && typeof value === 'string' && ['true', 'false', ''].includes(value)) {
         return null;
       }
 
       return options ? 'must be of type boolean' : null;
     },
     isObject: (value: any, options?: any): string | null => {
-      if (_.isUndefined(value) || _.isNil(options)) {
+      if (value === undefined || options == null) {
         return null;
       }
 
-      if (_.isPlainObject(value)) {
+      if (util.isPlainObject(value)) {
         return options ? null : 'must not be a plain object';
       }
 
       return options ? 'must be a plain object' : null;
     },
     isArray: (value: any, options?: any): string | null => {
-      if (_.isUndefined(value) || _.isNil(options)) {
+      if (value === undefined || options == null) {
         return null;
       }
 
-      if (_.isArray(value)) {
+      if (Array.isArray(value)) {
         return options ? null : 'must not be of type array';
       }
 
       return options ? 'must be of type array' : null;
     },
     deprecated: (value: any, options?: any, key?: string): string | null => {
-      if (!_.isUndefined(value) && options) {
+      if (value !== undefined && options) {
         log.warn(
           `The '${key}' capability has been deprecated and must not be used anymore. ` +
-          `Please check the driver documentation for possible alternatives.`
+            `Please check the driver documentation for possible alternatives.`,
         );
       }
       return null;
     },
     inclusion: (value: any, options?: any): string | null => {
-      if (_.isUndefined(value) || !options) {
+      if (value === undefined || !options) {
         return null;
       }
-      const optionsArr = _.isArray(options) ? options : [options];
+      const optionsArr = Array.isArray(options) ? options : [options];
       if (optionsArr.some((opt) => opt === value)) {
         return null;
       }
       return `must be contained by ${JSON.stringify(optionsArr)}`;
     },
     inclusionCaseInsensitive: (value: any, options?: any): string | null => {
-      if (_.isUndefined(value) || !options) {
+      if (value === undefined || !options) {
         return null;
       }
-      const optionsArr = _.isArray(options) ? options : [options];
-      if (optionsArr.some((opt) => _.toLower(opt) === _.toLower(value))) {
+      const optionsArr = Array.isArray(options) ? options : [options];
+      if (optionsArr.some((opt) => String(opt).toLowerCase() === String(value).toLowerCase())) {
         return null;
       }
       return `must be contained by ${JSON.stringify(optionsArr)}`;
     },
     presence: (value: any, options?: any): string | null => {
-      if (_.isUndefined(value) && options) {
+      if (value === undefined && options) {
         return 'is required to be present';
       }
       if (
         !options?.allowEmpty &&
-        ((!_.isUndefined(value) && _.isEmpty(value)) || (_.isString(value) && !_.trim(value)))
+        ((value !== undefined && util.isEmpty(value)) ||
+          (typeof value === 'string' && !value.trim()))
       ) {
         return 'must not be empty or blank';
       }
       return null;
-    }
+    },
   };
 
-  validate(values: Record<string, any>, constraints: Record<string, Constraint>): Record<string, string[]> | null {
+  validate(
+    values: Record<string, any>,
+    constraints: Record<string, Constraint>,
+  ): Record<string, string[]> | null {
     const result: Record<string, string[]> = {};
-    for (const [key, constraint] of _.toPairs(constraints)) {
+    for (const [key, constraint] of Object.entries(constraints)) {
       const value = values[key];
-      for (const [validatorName, options] of _.toPairs(constraint)) {
+      for (const [validatorName, options] of Object.entries(constraint)) {
         if (!(validatorName in this._validators)) {
           continue;
         }
 
-        const validationError = this._validators[validatorName](value, options, key);
-        if (_.isNil(validationError)) {
+        const validationError = this._validators[validatorName as keyof Constraint](
+          value,
+          options,
+          key,
+        );
+        if (validationError == null) {
           continue;
         }
 
@@ -137,9 +145,8 @@ export class Validator {
         }
       }
     }
-    return _.isEmpty(result) ? null : result;
+    return util.isEmpty(result) ? null : result;
   }
-
 }
 
 export const validator = new Validator();

package/lib/express/express-logging.ts

@@ -1,10 +1,8 @@
-import _ from 'lodash';
-import '@colors/colors';
+import {console, logger, util} from '@appium/support';
 import morgan from 'morgan';
 import type {Request, RequestHandler, Response} from 'express';
 import {log} from './logger';
 import {MAX_LOG_BODY_LENGTH} from '../constants';
-import {logger} from '@appium/support';
 
 /**
  * Morgan middleware that logs when the HTTP response finishes.
@@ -24,17 +22,18 @@ export const startLogFormatter: RequestHandler = morgan(startLogFormatterHandler
 type MorganTokens = unknown;
 type FormatFn = (tokens: MorganTokens, req: Request, res: Response) => string;
 
-function endLogFormatterHandler(tokens: MorganTokens, req: Request, res: Response): void {
+function endLogFormatterHandler(tokens: MorganTokens, req: Request, res: Response): undefined {
   log.info(requestEndLoggingFormat(tokens, req, res));
+  return undefined;
 }
 
-function startLogFormatterHandler(tokens: unknown, req: Request, res: Response): void {
+function startLogFormatterHandler(tokens: unknown, req: Request, res: Response): undefined {
   let reqBody = '';
   if (req.body) {
     try {
-      reqBody = _.truncate(
-        _.isString(req.body) ? req.body : JSON.stringify(req.body),
-        {length: MAX_LOG_BODY_LENGTH}
+      reqBody = util.truncateString(
+        typeof req.body === 'string' ? req.body : JSON.stringify(req.body),
+        {length: MAX_LOG_BODY_LENGTH},
       );
     } catch {
       // ignore
@@ -42,8 +41,9 @@ function startLogFormatterHandler(tokens: unknown, req: Request, res: Response):
   }
   log.info(
     requestStartLoggingFormat(tokens, req, res),
-    logger.markSensitive(reqBody.grey)
+    logger.markSensitive(console.styleText('grey', reqBody)),
   );
+  return undefined;
 }
 
 // Copied the morgan compile function over so that cooler formats may be configured
@@ -56,29 +56,25 @@ function compile(fmt: string): FormatFn {
   return new Function('tokens', 'req', 'res', js) as FormatFn;
 }
 
-function requestEndLoggingFormat(
-  tokens: MorganTokens,
-  req: Request,
-  res: Response
-): string {
+function requestEndLoggingFormat(tokens: MorganTokens, req: Request, res: Response): string {
   const status = res.statusCode;
   let statusStr = ':status';
   if (status >= 500) {
-    statusStr = statusStr.red;
+    statusStr = console.styleText('red', statusStr);
   } else if (status >= 400) {
-    statusStr = statusStr.yellow;
+    statusStr = console.styleText('yellow', statusStr);
   } else if (status >= 300) {
-    statusStr = statusStr.cyan;
+    statusStr = console.styleText('cyan', statusStr);
   } else {
-    statusStr = statusStr.green;
+    statusStr = console.styleText('green', statusStr);
   }
   const fn = compile(
-    `${'<-- :method :url '.white}${statusStr} ${':response-time ms - :res[content-length]'.grey}`
+    `${console.styleText('white', '<-- :method :url ')}${statusStr} ${console.styleText('grey', ':response-time ms - :res[content-length]')}`,
   );
   return fn(tokens, req, res);
 }
 
 const requestStartLoggingFormat = compile(
-  `${'-->'.white} ${':method'.white} ${':url'.white}`
+  `${console.styleText('white', '-->')} ${console.styleText('white', ':method')} ${console.styleText('white', ':url')}`,
 );
 // #endregion

package/lib/express/idempotency.ts

@@ -1,6 +1,6 @@
 import {log} from './logger';
 import {LRUCache} from 'lru-cache';
-import _ from 'lodash';
+import {util} from '@appium/support';
 import {EventEmitter} from 'node:events';
 import type {Request, Response, NextFunction} from 'express';
 
@@ -31,15 +31,15 @@ const MAX_CACHED_PAYLOAD_SIZE_BYTES = 1 * 1024 * 1024; // 1 MiB
 export async function handleIdempotency(
   req: Request,
   res: Response,
-  next: NextFunction
+  next: NextFunction,
 ): Promise<void> {
   const keyOrArr = req.headers[IDEMPOTENCY_KEY_HEADER];
-  if (_.isEmpty(keyOrArr) || !keyOrArr) {
+  if (util.isEmpty(keyOrArr) || !keyOrArr) {
     next();
     return;
   }
 
-  const key = _.isArray(keyOrArr) ? keyOrArr[0] : keyOrArr;
+  const key = Array.isArray(keyOrArr) ? keyOrArr[0] : keyOrArr;
 
   log.updateAsyncContext({idempotencyKey: key});
 
@@ -114,7 +114,7 @@ function cacheResponse(key: string, req: Request, res: Response): void {
   const patchedWriter = (
     chunk: unknown,
     encoding: BufferEncoding | (() => void),
-    next?: (() => void) | ((err?: Error) => void)
+    next?: (() => void) | ((err?: Error) => void),
   ): boolean => {
     if (errorMessage || !responseRef.deref()) {
       responseChunks = [];
@@ -122,7 +122,7 @@ function cacheResponse(key: string, req: Request, res: Response): void {
       return originalSocketWriter(
         chunk as string | Buffer | Uint8Array,
         encoding as BufferEncoding,
-        next as (err?: Error) => void
+        next as (err?: Error | null) => void,
       );
     }
 
@@ -139,7 +139,7 @@ function cacheResponse(key: string, req: Request, res: Response): void {
     return originalSocketWriter(
       chunk as string | Buffer | Uint8Array,
       encoding as BufferEncoding,
-      next as (err?: Error) => void
+      next as (err?: Error | null) => void,
     );
   };
   socket.write = patchedWriter as typeof socket.write;
@@ -153,7 +153,7 @@ function cacheResponse(key: string, req: Request, res: Response): void {
     if (!IDEMPOTENT_RESPONSES.has(key)) {
       log.info(
         `Could not cache the response identified by '${key}'. ` +
-          `Cache consistency has been damaged`
+          `Cache consistency has been damaged`,
       );
     } else {
       log.info(`Could not cache the response identified by '${key}': ${errorMessage}`);
@@ -175,7 +175,7 @@ function cacheResponse(key: string, req: Request, res: Response): void {
     if (!IDEMPOTENT_RESPONSES.has(key)) {
       log.info(
         `Could not cache the response identified by '${key}'. ` +
-          `Cache consistency has been damaged`
+          `Cache consistency has been damaged`,
       );
     } else if (errorMessage) {
       log.info(`Could not cache the response identified by '${key}': ${errorMessage}`);

package/lib/express/middleware.ts

@@ -1,4 +1,4 @@
-import _ from 'lodash';
+import {util} from '@appium/support';
 import type {NextFunction, Request, RequestHandler, Response} from 'express';
 import type {IncomingMessage} from 'node:http';
 import type {Duplex} from 'node:stream';
@@ -6,7 +6,6 @@ import {log} from './logger';
 import {errors} from '../protocol';
 export {handleIdempotency} from './idempotency';
 import {match} from 'path-to-regexp';
-import {util} from '@appium/support';
 import {calcSignature} from '../helpers/session';
 import {getResponseForW3CError} from '../protocol/errors';
 import type {StringRecord, WSServer} from '@appium/types';
@@ -22,7 +21,7 @@ export function allowCrossDomain(req: Request, res: Response, next: NextFunction
   res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, OPTIONS, DELETE');
   res.header(
     'Access-Control-Allow-Headers',
-    'Cache-Control, Pragma, Origin, X-Requested-With, Content-Type, Accept, User-Agent'
+    'Cache-Control, Pragma, Origin, X-Requested-With, Content-Type, Accept, User-Agent',
   );
 
   if (req.method === 'OPTIONS') {
@@ -43,10 +42,10 @@ export function allowCrossDomainAsyncExecute(basePath: string): RequestHandler {
   function allowCrossDomainAsyncExecuteHandler(
     req: Request,
     res: Response,
-    next: NextFunction
+    next: NextFunction,
   ): void {
     const receiveAsyncResponseRegExp = new RegExp(
-      `${_.escapeRegExp(basePath)}/session/[a-f0-9-]+/(appium/)?receive_async_response`
+      `${util.escapeRegExp(basePath)}/session/[a-f0-9-]+/(appium/)?receive_async_response`,
     );
     if (!receiveAsyncResponseRegExp.test(req.url)) {
       next();
@@ -73,9 +72,11 @@ export function handleLogContext(req: Request, _res: Response, next: NextFunctio
     {
       requestId,
       ...sessionInfo,
-      isSensitive: ['true', '1', 'yes'].includes(_.toLower(isSensitiveHeaderValue)),
+      isSensitive: ['true', '1', 'yes'].includes(
+        String(isSensitiveHeaderValue ?? '').toLowerCase(),
+      ),
     },
-    true
+    true,
   );
 
   next();
@@ -84,11 +85,7 @@ export function handleLogContext(req: Request, _res: Response, next: NextFunctio
 /**
  * Ensures requests default to JSON content-type when none is provided.
  */
-export function defaultToJSONContentType(
-  req: Request,
-  _res: Response,
-  next: NextFunction
-): void {
+export function defaultToJSONContentType(req: Request, _res: Response, next: NextFunction): void {
   if (!req.headers['content-type']) {
     req.headers['content-type'] = 'application/json; charset=utf-8';
   }
@@ -108,9 +105,9 @@ export function tryHandleWebSocketUpgrade(
   req: IncomingMessage,
   socket: Duplex,
   head: Buffer,
-  webSocketsMapping: StringRecord<WSServer>
+  webSocketsMapping: StringRecord<WSServer>,
 ): boolean {
-  if (_.toLower(req.headers?.upgrade) !== 'websocket') {
+  if (String(req.headers?.upgrade ?? '').toLowerCase() !== 'websocket') {
     return false;
   }
 
@@ -120,7 +117,7 @@ export function tryHandleWebSocketUpgrade(
   } catch {
     currentPathname = req.url ?? '';
   }
-  for (const [pathname, wsServer] of _.toPairs(webSocketsMapping)) {
+  for (const [pathname, wsServer] of Object.entries(webSocketsMapping)) {
     if (match(pathname)(currentPathname)) {
       wsServer.handleUpgrade(req, socket, head, (ws) => {
         wsServer.emit('connection', ws, req);
@@ -158,7 +155,7 @@ export function catchAllHandler(
   err: Error,
   _req: Request,
   res: Response,
-  next: NextFunction
+  next: NextFunction,
 ): void {
   if (res.headersSent) {
     next(err);
@@ -182,6 +179,5 @@ export function catch404Handler(req: Request, res: Response): void {
 
 function fetchHeaderValue(req: Request, name: string): string | undefined {
   const value = req.headers[name];
-  return _.isArray(value) ? value[0] : (value as string | undefined);
+  return Array.isArray(value) ? value[0] : (value as string | undefined);
 }
-