appium 2.0.0-beta.4 → 2.0.0-beta.40

package/build/lib/main.js

@@ -1,14 +1,38 @@
 #!/usr/bin/env node
 "use strict";
 
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
-
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "finalizeSchema", {
+  enumerable: true,
+  get: function () {
+    return _schema.finalizeSchema;
+  }
+});
+Object.defineProperty(exports, "getSchema", {
+  enumerable: true,
+  get: function () {
+    return _schema.getSchema;
+  }
+});
+exports.init = init;
 exports.main = main;
+Object.defineProperty(exports, "readConfigFile", {
+  enumerable: true,
+  get: function () {
+    return _configFile.readConfigFile;
+  }
+});
+exports.resolveAppiumHome = void 0;
+Object.defineProperty(exports, "validate", {
+  enumerable: true,
+  get: function () {
+    return _schema.validate;
+  }
+});
 
 require("source-map-support/register");
 
@@ -16,41 +40,40 @@ var _logsink = require("./logsink");
 
 var _logger = _interopRequireDefault(require("./logger"));
 
-var _lodash = _interopRequireDefault(require("lodash"));
+var _baseDriver = require("@appium/base-driver");
 
-var _appiumBaseDriver = require("appium-base-driver");
+var _support = require("@appium/support");
 
 var _asyncbox = require("asyncbox");
 
-var _parser = _interopRequireWildcard(require("./cli/parser"));
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _appium = require("./appium");
 
-var _args = require("./cli/args");
+var _extension = require("./cli/extension");
 
-var _appiumSupport = require("appium-support");
+var _parser = require("./cli/parser");
 
 var _config = require("./config");
 
-var _driverConfig = _interopRequireDefault(require("./driver-config"));
+var _configFile = require("./config-file");
 
-var _pluginConfig = _interopRequireDefault(require("./plugin-config"));
+var _extension2 = require("./extension");
 
-var _extensionConfig = require("./extension-config");
-
-var _extension = require("./cli/extension");
-
-var _appium = require("./appium");
+var _constants = require("./constants");
 
 var _gridRegister = _interopRequireDefault(require("./grid-register"));
 
+var _schema = require("./schema/schema");
+
 var _utils = require("./utils");
 
-async function preflightChecks({
-  parser,
-  args,
-  driverConfig,
-  pluginConfig,
-  throwInsteadOfExit = false
-}) {
+const {
+  resolveAppiumHome
+} = _support.env;
+exports.resolveAppiumHome = resolveAppiumHome;
+
+async function preflightChecks(args, throwInsteadOfExit = false) {
   try {
     (0, _config.checkNodeOk)();
 
@@ -58,15 +81,13 @@ async function preflightChecks({
       require('longjohn').async_trace_limit = -1;
     }
 
-    if (args.showConfig) {
-      await (0, _config.showConfig)();
+    if (args.showBuildInfo) {
+      await (0, _config.showBuildInfo)();
       process.exit(0);
     }
 
     (0, _config.warnNodeDeprecations)();
-    (0, _config.validateServerArgs)(parser, args);
-    await driverConfig.read();
-    await pluginConfig.read();
+    (0, _schema.validate)(args);
 
     if (args.tmpDir) {
       await (0, _config.validateTmpDir)(args.tmpDir);
@@ -85,16 +106,16 @@ async function preflightChecks({
 function logNonDefaultArgsWarning(args) {
   _logger.default.info('Non-default server args:');
 
-  (0, _utils.inspectObject)(args);
+  (0, _utils.inspect)(args);
 }
 
 function logDefaultCapabilitiesWarning(caps) {
   _logger.default.info('Default capabilities, which will be added to each request ' + 'unless overridden by desired capabilities:');
 
-  (0, _utils.inspectObject)(caps);
+  (0, _utils.inspect)(caps);
 }
 
-async function logStartupInfo(parser, args) {
+async function logStartupInfo(args) {
   let welcome = `Welcome to Appium v${_config.APPIUM_VER}`;
   let appiumRev = await (0, _config.getGitRev)();
 
@@ -104,7 +125,7 @@ async function logStartupInfo(parser, args) {
 
   _logger.default.info(welcome);
 
-  let showArgs = (0, _config.getNonDefaultArgs)(parser, args);
+  let showArgs = (0, _config.getNonDefaultServerArgs)(args);
 
   if (_lodash.default.size(showArgs)) {
     logNonDefaultArgsWarning(showArgs);
@@ -121,88 +142,168 @@ function logServerPort(address, port) {
   _logger.default.info(logMessage);
 }
 
-async function main(args = null) {
-  let parser = (0, _parser.default)();
+function getServerUpdaters(driverClasses, pluginClasses) {
+  return _lodash.default.compact(_lodash.default.map([...driverClasses.keys(), ...pluginClasses.keys()], 'updateServer'));
+}
+
+function getExtraMethodMap(driverClasses, pluginClasses) {
+  return [...driverClasses.keys(), ...pluginClasses.keys()].reduce((map, klass) => {
+    var _klass$newMethodMap;
+
+    return { ...map,
+      ...((_klass$newMethodMap = klass.newMethodMap) !== null && _klass$newMethodMap !== void 0 ? _klass$newMethodMap : {})
+    };
+  }, {});
+}
+
+function areServerCommandArgs(args) {
+  return args.subcommand === _constants.SERVER_SUBCOMMAND;
+}
+
+async function init(args) {
+  var _args$appiumHome;
+
+  const appiumHome = (_args$appiumHome = args === null || args === void 0 ? void 0 : args.appiumHome) !== null && _args$appiumHome !== void 0 ? _args$appiumHome : await resolveAppiumHome();
+  const {
+    driverConfig,
+    pluginConfig
+  } = await (0, _extension2.loadExtensions)(appiumHome);
+  const parser = (0, _parser.getParser)();
   let throwInsteadOfExit = false;
+  let preConfigArgs;
 
   if (args) {
-    args = Object.assign({}, (0, _parser.getDefaultServerArgs)(), args);
+    var _args$subcommand;
 
     if (args.throwInsteadOfExit) {
       throwInsteadOfExit = true;
       delete args.throwInsteadOfExit;
     }
+
+    preConfigArgs = { ...args,
+      subcommand: (_args$subcommand = args.subcommand) !== null && _args$subcommand !== void 0 ? _args$subcommand : _constants.SERVER_SUBCOMMAND
+    };
   } else {
-    args = parser.parseArgs();
+    preConfigArgs = parser.parseArgs();
   }
 
-  await (0, _logsink.init)(args);
+  const configResult = await (0, _configFile.readConfigFile)(preConfigArgs.configFile);
+
+  if (!_lodash.default.isEmpty(configResult.errors)) {
+    var _configResult$reason;
 
-  if (args.subcommand === _extensionConfig.DRIVER_TYPE || args.subcommand === _extensionConfig.PLUGIN_TYPE) {
-    await (0, _extension.runExtensionCommand)(args, args.subcommand);
-    process.exit();
+    throw new Error(`Errors in config file ${configResult.filepath}:\n ${(_configResult$reason = configResult.reason) !== null && _configResult$reason !== void 0 ? _configResult$reason : configResult.errors}`);
   }
 
-  if (args.logFilters) {
-    const {
-      issues,
-      rules
-    } = await _appiumSupport.logger.loadSecureValuesPreprocessingRules(args.logFilters);
+  if (!areServerCommandArgs(preConfigArgs)) {
+    if (preConfigArgs.subcommand === _constants.DRIVER_TYPE) {
+      await (0, _extension.runExtensionCommand)(preConfigArgs, driverConfig);
+      return {};
+    }
+
+    if (preConfigArgs.subcommand === _constants.PLUGIN_TYPE) {
+      await (0, _extension.runExtensionCommand)(preConfigArgs, pluginConfig);
+      return {};
+    }
+
+    return {};
+  } else {
+    var _configResult$config;
+
+    const defaults = (0, _schema.getDefaultsForSchema)(false);
 
-    if (!_lodash.default.isEmpty(issues)) {
-      throw new Error(`The log filtering rules config '${args.logFilters}' has issues: ` + JSON.stringify(issues, null, 2));
+    const serverArgs = _lodash.default.defaultsDeep(preConfigArgs, (_configResult$config = configResult.config) === null || _configResult$config === void 0 ? void 0 : _configResult$config.server, defaults);
+
+    if (preConfigArgs.showConfig) {
+      (0, _config.showConfig)((0, _config.getNonDefaultServerArgs)(preConfigArgs), configResult, defaults, serverArgs);
+      return {};
     }
 
-    if (_lodash.default.isEmpty(rules)) {
-      _logger.default.warn(`Found no log filtering rules in '${args.logFilters}'. Is that expected?`);
-    } else {
-      _logger.default.info(`Loaded ${_appiumSupport.util.pluralize('filtering rule', rules.length, true)} from '${args.logFilters}'`);
+    await (0, _logsink.init)(serverArgs);
+
+    if (serverArgs.logFilters) {
+      const {
+        issues,
+        rules
+      } = await _support.logger.loadSecureValuesPreprocessingRules(serverArgs.logFilters);
+
+      if (!_lodash.default.isEmpty(issues)) {
+        throw new Error(`The log filtering rules config '${serverArgs.logFilters}' has issues: ` + JSON.stringify(issues, null, 2));
+      }
+
+      if (_lodash.default.isEmpty(rules)) {
+        _logger.default.warn(`Found no log filtering rules in '${serverArgs.logFilters}'. Is that expected?`);
+      } else {
+        _logger.default.info(`Loaded ${_support.util.pluralize('filtering rule', rules.length, true)} from '${serverArgs.logFilters}'`);
+      }
     }
+
+    const appiumDriver = new _appium.AppiumDriver(serverArgs);
+    appiumDriver.driverConfig = driverConfig;
+    await preflightChecks(serverArgs, throwInsteadOfExit);
+    return {
+      appiumDriver,
+      parsedArgs: serverArgs,
+      driverConfig,
+      pluginConfig
+    };
   }
+}
 
-  let appiumDriver = new _appium.AppiumDriver(args);
-  const driverConfig = new _driverConfig.default(args.appiumHome);
-  const pluginConfig = new _pluginConfig.default(args.appiumHome);
-  appiumDriver.driverConfig = driverConfig;
-  await preflightChecks({
-    parser,
-    args,
-    driverConfig,
+async function main(args) {
+  const {
+    appiumDriver,
+    parsedArgs,
     pluginConfig,
-    throwInsteadOfExit
-  });
-  await logStartupInfo(parser, args);
-  let routeConfiguringFunction = (0, _appiumBaseDriver.routeConfiguringFunction)(appiumDriver);
-  const plugins = Object.keys(pluginConfig.installedExtensions).filter(pluginName => _lodash.default.includes(args.plugins, pluginName) || args.plugins.length === 1 && args.plugins[0] === _args.USE_ALL_PLUGINS).map(pluginName => {
-    try {
-      const PluginClass = pluginConfig.require(pluginName);
-
-      return new PluginClass(pluginName);
-    } catch (err) {
-      _logger.default.error(`Could not load plugin '${pluginName}', so it will not be available. Error ` + `in loading the plugin was: ${err}`);
-
-      return false;
-    }
-  }).filter(Boolean);
-  appiumDriver.plugins = plugins;
-  let server = await (0, _appiumBaseDriver.server)({
+    driverConfig
+  } = await init(args);
+
+  if (!appiumDriver || !parsedArgs || !pluginConfig || !driverConfig) {
+    return;
+  }
+
+  const pluginClasses = (0, _extension2.getActivePlugins)(pluginConfig, parsedArgs.usePlugins);
+  appiumDriver.pluginClasses = pluginClasses;
+  await logStartupInfo(parsedArgs);
+  let routeConfiguringFunction = (0, _baseDriver.routeConfiguringFunction)(appiumDriver);
+  const driverClasses = (0, _extension2.getActiveDrivers)(driverConfig, parsedArgs.useDrivers);
+  const serverUpdaters = getServerUpdaters(driverClasses, pluginClasses);
+  const extraMethodMap = getExtraMethodMap(driverClasses, pluginClasses);
+  const serverOpts = {
     routeConfiguringFunction,
-    port: args.port,
-    hostname: args.address,
-    allowCors: args.allowCors,
-    basePath: args.basePath,
-    plugins
-  });
-
-  if (args.allowCors) {
+    port: parsedArgs.port,
+    hostname: parsedArgs.address,
+    allowCors: parsedArgs.allowCors,
+    basePath: parsedArgs.basePath,
+    serverUpdaters,
+    extraMethodMap
+  };
+
+  if (parsedArgs.keepAliveTimeout) {
+    serverOpts.keepAliveTimeout = parsedArgs.keepAliveTimeout * 1000;
+  }
+
+  let server;
+
+  try {
+    server = await (0, _baseDriver.server)(serverOpts);
+  } catch (err) {
+    _logger.default.error(`Could not configure Appium server. It's possible that a driver or plugin tried ` + `to update the server and failed. Original error: ${err.message}`);
+
+    _logger.default.debug(err.stack);
+
+    return process.exit(1);
+  }
+
+  if (parsedArgs.allowCors) {
     _logger.default.warn('You have enabled CORS requests from any host. Be careful not ' + 'to visit sites which could maliciously try to start Appium ' + 'sessions on your machine');
   }
 
   appiumDriver.server = server;
 
   try {
-    if (args.nodeconfig !== null) {
-      await (0, _gridRegister.default)(args.nodeconfig, args.address, args.port, args.basePath);
+    if (parsedArgs.nodeconfig) {
+      await (0, _gridRegister.default)(parsedArgs.nodeconfig, parsedArgs.address, parsedArgs.port, parsedArgs.basePath);
     }
   } catch (err) {
     await server.close();
@@ -228,15 +329,13 @@ async function main(args = null) {
     });
   }
 
-  logServerPort(args.address, args.port);
+  logServerPort(parsedArgs.address, parsedArgs.port);
   driverConfig.print();
-  pluginConfig.print(plugins);
+  pluginConfig.print([...pluginClasses.values()]);
   return server;
 }
 
 if (require.main === module) {
   (0, _asyncbox.asyncify)(main);
-}require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/main.js"],"names":["preflightChecks","parser","args","driverConfig","pluginConfig","throwInsteadOfExit","longStacktrace","require","async_trace_limit","showConfig","process","exit","read","tmpDir","err","logger","error","message","red","logNonDefaultArgsWarning","info","logDefaultCapabilitiesWarning","caps","logStartupInfo","welcome","APPIUM_VER","appiumRev","showArgs","_","size","isEmpty","defaultCapabilities","logServerPort","address","port","logMessage","main","Object","assign","parseArgs","subcommand","DRIVER_TYPE","PLUGIN_TYPE","logFilters","issues","rules","logFactory","loadSecureValuesPreprocessingRules","Error","JSON","stringify","warn","util","pluralize","length","appiumDriver","AppiumDriver","DriverConfig","appiumHome","PluginConfig","routeConfiguringFunction","plugins","keys","installedExtensions","filter","pluginName","includes","USE_ALL_PLUGINS","map","PluginClass","Boolean","server","hostname","allowCors","basePath","nodeconfig","close","signal","once","onSignal","deleteAllSessions","force","reason","e","print","module"],"mappings":"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","sourcesContent":["#!/usr/bin/env node\n// transpile:main\n\nimport { init as logsinkInit } from './logsink';\nimport logger from './logger'; // logger needs to remain first of imports\nimport _ from 'lodash';\nimport { server as baseServer, routeConfiguringFunction as makeRouter } from 'appium-base-driver';\nimport { asyncify } from 'asyncbox';\nimport { default as getParser, getDefaultServerArgs } from './cli/parser';\nimport { USE_ALL_PLUGINS } from './cli/args';\nimport { logger as logFactory, util } from 'appium-support';\nimport {\n  showConfig, checkNodeOk, validateServerArgs,\n  warnNodeDeprecations, validateTmpDir, getNonDefaultArgs,\n  getGitRev, APPIUM_VER\n} from './config';\nimport DriverConfig from './driver-config';\nimport PluginConfig from './plugin-config';\nimport { DRIVER_TYPE, PLUGIN_TYPE } from './extension-config';\nimport { runExtensionCommand } from './cli/extension';\nimport { AppiumDriver } from './appium';\nimport registerNode from './grid-register';\nimport { inspectObject } from './utils';\n\n\nasync function preflightChecks ({parser, args, driverConfig, pluginConfig, throwInsteadOfExit = false}) {\n  try {\n    checkNodeOk();\n    if (args.longStacktrace) {\n      require('longjohn').async_trace_limit = -1;\n    }\n    if (args.showConfig) {\n      await showConfig();\n      process.exit(0);\n    }\n    warnNodeDeprecations();\n    validateServerArgs(parser, args);\n    await driverConfig.read();\n    await pluginConfig.read();\n    if (args.tmpDir) {\n      await validateTmpDir(args.tmpDir);\n    }\n  } catch (err) {\n    logger.error(err.message.red);\n    if (throwInsteadOfExit) {\n      throw err;\n    }\n\n    process.exit(1);\n  }\n}\n\nfunction logNonDefaultArgsWarning (args) {\n  logger.info('Non-default server args:');\n  inspectObject(args);\n}\n\nfunction logDefaultCapabilitiesWarning (caps) {\n  logger.info('Default capabilities, which will be added to each request ' +\n              'unless overridden by desired capabilities:');\n  inspectObject(caps);\n}\n\nasync function logStartupInfo (parser, args) {\n  let welcome = `Welcome to Appium v${APPIUM_VER}`;\n  let appiumRev = await getGitRev();\n  if (appiumRev) {\n    welcome += ` (REV ${appiumRev})`;\n  }\n  logger.info(welcome);\n\n  let showArgs = getNonDefaultArgs(parser, args);\n  if (_.size(showArgs)) {\n    logNonDefaultArgsWarning(showArgs);\n  }\n  if (!_.isEmpty(args.defaultCapabilities)) {\n    logDefaultCapabilitiesWarning(args.defaultCapabilities);\n  }\n  // TODO: bring back loglevel reporting below once logger is flushed out\n  // logger.info('Console LogLevel: ' + logger.transports.console.level);\n  // if (logger.transports.file) {\n  //   logger.info('File LogLevel: ' + logger.transports.file.level);\n  // }\n}\n\nfunction logServerPort (address, port) {\n  let logMessage = `Appium REST http interface listener started on ` +\n                   `${address}:${port}`;\n  logger.info(logMessage);\n}\n\nasync function main (args = null) {\n  let parser = getParser();\n  let throwInsteadOfExit = false;\n  if (args) {\n    // a containing package passed in their own args, let's fill them out\n    // with defaults\n    args = Object.assign({}, getDefaultServerArgs(), args);\n\n    // if we have a containing package instead of running as a CLI process,\n    // that package might not appreciate us calling 'process.exit' willy-\n    // nilly, so give it the option to have us throw instead of exit\n    if (args.throwInsteadOfExit) {\n      throwInsteadOfExit = true;\n      // but remove it since it's not a real server arg per se\n      delete args.throwInsteadOfExit;\n    }\n  } else {\n    // otherwise parse from CLI\n    args = parser.parseArgs();\n  }\n  await logsinkInit(args);\n\n  // if the user has requested the 'driver' CLI, don't run the normal server,\n  // but instead pass control to the driver CLI\n  if (args.subcommand === DRIVER_TYPE || args.subcommand === PLUGIN_TYPE) {\n    await runExtensionCommand(args, args.subcommand);\n    process.exit();\n  }\n\n  if (args.logFilters) {\n    const {issues, rules} = await logFactory.loadSecureValuesPreprocessingRules(args.logFilters);\n    if (!_.isEmpty(issues)) {\n      throw new Error(`The log filtering rules config '${args.logFilters}' has issues: ` +\n        JSON.stringify(issues, null, 2));\n    }\n    if (_.isEmpty(rules)) {\n      logger.warn(`Found no log filtering rules in '${args.logFilters}'. Is that expected?`);\n    } else {\n      logger.info(`Loaded ${util.pluralize('filtering rule', rules.length, true)} from '${args.logFilters}'`);\n    }\n  }\n\n  let appiumDriver = new AppiumDriver(args);\n  const driverConfig = new DriverConfig(args.appiumHome);\n  const pluginConfig = new PluginConfig(args.appiumHome);\n  appiumDriver.driverConfig = driverConfig;\n  await preflightChecks({parser, args, driverConfig, pluginConfig, throwInsteadOfExit});\n  await logStartupInfo(parser, args);\n  let routeConfiguringFunction = makeRouter(appiumDriver);\n\n  // find any plugin name which has been installed, and which has been requested for activation by\n  // using the --plugins flag, and turn each one into an instantiated plugin object, so we can send\n  // them as objects to the server init. we also want to send/assign them to the umbrella driver so\n  // it can use them to wrap command execution\n  const plugins = Object.keys(pluginConfig.installedExtensions).filter((pluginName) =>\n    _.includes(args.plugins, pluginName) ||\n    (args.plugins.length === 1 && args.plugins[0] === USE_ALL_PLUGINS)\n  ).map((pluginName) => {\n    try {\n      const PluginClass = pluginConfig.require(pluginName);\n      return new PluginClass(pluginName);\n    } catch (err) {\n      logger.error(`Could not load plugin '${pluginName}', so it will not be available. Error ` +\n                   `in loading the plugin was: ${err}`);\n      return false;\n    }\n  }).filter(Boolean);\n  appiumDriver.plugins = plugins;\n\n  let server = await baseServer({\n    routeConfiguringFunction,\n    port: args.port,\n    hostname: args.address,\n    allowCors: args.allowCors,\n    basePath: args.basePath,\n    plugins,\n  });\n  if (args.allowCors) {\n    logger.warn('You have enabled CORS requests from any host. Be careful not ' +\n                'to visit sites which could maliciously try to start Appium ' +\n                'sessions on your machine');\n  }\n  appiumDriver.server = server;\n  try {\n    // TODO prelaunch if args.launch is set\n    // TODO: startAlertSocket(server, appiumServer);\n\n    // configure as node on grid, if necessary\n    if (args.nodeconfig !== null) {\n      await registerNode(args.nodeconfig, args.address, args.port, args.basePath);\n    }\n  } catch (err) {\n    await server.close();\n    throw err;\n  }\n\n  for (const signal of ['SIGINT', 'SIGTERM']) {\n    process.once(signal, async function onSignal () {\n      logger.info(`Received ${signal} - shutting down`);\n      try {\n        await appiumDriver.deleteAllSessions({\n          force: true,\n          reason: `The process has received ${signal} signal`,\n        });\n        await server.close();\n        process.exit(0);\n      } catch (e) {\n        logger.warn(e);\n        process.exit(1);\n      }\n    });\n  }\n\n  logServerPort(args.address, args.port);\n  driverConfig.print();\n  pluginConfig.print(plugins);\n\n  return server;\n}\n\nif (require.main === module) {\n  asyncify(main);\n}\n\nexport { main };\n"],"file":"lib/main.js","sourceRoot":"../.."}
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["resolveAppiumHome","env","preflightChecks","args","throwInsteadOfExit","checkNodeOk","longStacktrace","require","async_trace_limit","showBuildInfo","process","exit","warnNodeDeprecations","validate","tmpDir","validateTmpDir","err","logger","error","message","red","logNonDefaultArgsWarning","info","inspect","logDefaultCapabilitiesWarning","caps","logStartupInfo","welcome","APPIUM_VER","appiumRev","getGitRev","showArgs","getNonDefaultServerArgs","_","size","isEmpty","defaultCapabilities","logServerPort","address","port","logMessage","getServerUpdaters","driverClasses","pluginClasses","compact","map","keys","getExtraMethodMap","reduce","klass","newMethodMap","areServerCommandArgs","subcommand","SERVER_SUBCOMMAND","init","appiumHome","driverConfig","pluginConfig","loadExtensions","parser","getParser","preConfigArgs","parseArgs","configResult","readConfigFile","configFile","errors","Error","filepath","reason","DRIVER_TYPE","runExtensionCommand","PLUGIN_TYPE","defaults","getDefaultsForSchema","serverArgs","defaultsDeep","config","server","showConfig","logsinkInit","logFilters","issues","rules","logFactory","loadSecureValuesPreprocessingRules","JSON","stringify","warn","util","pluralize","length","appiumDriver","AppiumDriver","parsedArgs","main","getActivePlugins","usePlugins","routeConfiguringFunction","makeRouter","getActiveDrivers","useDrivers","serverUpdaters","extraMethodMap","serverOpts","hostname","allowCors","basePath","keepAliveTimeout","baseServer","debug","stack","nodeconfig","registerNode","close","signal","once","onSignal","deleteAllSessions","force","e","print","values","module","asyncify"],"sources":["../../lib/main.js"],"sourcesContent":["#!/usr/bin/env node\n\nimport {init as logsinkInit} from './logsink'; // this import needs to come first since it sets up global npmlog\nimport logger from './logger'; // logger needs to remain second\n// @ts-ignore\nimport {routeConfiguringFunction as makeRouter, server as baseServer} from '@appium/base-driver';\nimport {logger as logFactory, util, env} from '@appium/support';\nimport {asyncify} from 'asyncbox';\nimport _ from 'lodash';\nimport {AppiumDriver} from './appium';\nimport {runExtensionCommand} from './cli/extension';\nimport {getParser} from './cli/parser';\nimport {\n  APPIUM_VER,\n  checkNodeOk,\n  getGitRev,\n  getNonDefaultServerArgs,\n  showConfig,\n  showBuildInfo,\n  validateTmpDir,\n  warnNodeDeprecations,\n} from './config';\nimport {readConfigFile} from './config-file';\nimport {loadExtensions, getActivePlugins, getActiveDrivers} from './extension';\nimport {DRIVER_TYPE, PLUGIN_TYPE, SERVER_SUBCOMMAND} from './constants';\nimport registerNode from './grid-register';\nimport {getDefaultsForSchema, validate} from './schema/schema';\nimport {inspect} from './utils';\n\nconst {resolveAppiumHome} = env;\n\n/**\n *\n * @param {ParsedArgs} args\n * @param {boolean} [throwInsteadOfExit]\n */\nasync function preflightChecks(args, throwInsteadOfExit = false) {\n  try {\n    checkNodeOk();\n    if (args.longStacktrace) {\n      require('longjohn').async_trace_limit = -1;\n    }\n    if (args.showBuildInfo) {\n      await showBuildInfo();\n      process.exit(0);\n    }\n    warnNodeDeprecations();\n\n    validate(args);\n\n    if (args.tmpDir) {\n      await validateTmpDir(args.tmpDir);\n    }\n  } catch (err) {\n    logger.error(err.message.red);\n    if (throwInsteadOfExit) {\n      throw err;\n    }\n\n    process.exit(1);\n  }\n}\n\n/**\n * @param {Args} args\n */\nfunction logNonDefaultArgsWarning(args) {\n  logger.info('Non-default server args:');\n  inspect(args);\n}\n\n/**\n * @param {Args['defaultCapabilities']} caps\n */\nfunction logDefaultCapabilitiesWarning(caps) {\n  logger.info(\n    'Default capabilities, which will be added to each request ' +\n      'unless overridden by desired capabilities:'\n  );\n  inspect(caps);\n}\n\n/**\n * @param {ParsedArgs} args\n */\nasync function logStartupInfo(args) {\n  let welcome = `Welcome to Appium v${APPIUM_VER}`;\n  let appiumRev = await getGitRev();\n  if (appiumRev) {\n    welcome += ` (REV ${appiumRev})`;\n  }\n  logger.info(welcome);\n\n  let showArgs = getNonDefaultServerArgs(args);\n  if (_.size(showArgs)) {\n    logNonDefaultArgsWarning(showArgs);\n  }\n  if (!_.isEmpty(args.defaultCapabilities)) {\n    logDefaultCapabilitiesWarning(args.defaultCapabilities);\n  }\n  // TODO: bring back loglevel reporting below once logger is flushed out\n  // logger.info('Console LogLevel: ' + logger.transports.console.level);\n  // if (logger.transports.file) {\n  //   logger.info('File LogLevel: ' + logger.transports.file.level);\n  // }\n}\n\n/**\n * Logs the address and port the server is listening on\n * @param {string} address - Address\n * @param {number} port - Port\n * @returns {void}\n */\nfunction logServerPort(address, port) {\n  let logMessage = `Appium REST http interface listener started on ` + `${address}:${port}`;\n  logger.info(logMessage);\n}\n\n/**\n * Gets a list of `updateServer` functions from all extensions\n * @param {DriverNameMap} driverClasses\n * @param {PluginNameMap} pluginClasses\n * @returns {import('@appium/types').UpdateServerCallback[]}\n */\nfunction getServerUpdaters(driverClasses, pluginClasses) {\n  return _.compact(_.map([...driverClasses.keys(), ...pluginClasses.keys()], 'updateServer'));\n}\n\n/**\n * Makes a big `MethodMap` from all the little `MethodMap`s in the extensions\n * @param {DriverNameMap} driverClasses\n * @param {PluginNameMap} pluginClasses\n * @returns {import('@appium/types').MethodMap}\n */\nfunction getExtraMethodMap(driverClasses, pluginClasses) {\n  return [...driverClasses.keys(), ...pluginClasses.keys()].reduce(\n    (map, klass) => ({\n      ...map,\n      ...(klass.newMethodMap ?? {}),\n    }),\n    {}\n  );\n}\n\n/**\n * @template [T=WithServerSubcommand]\n * @param {Args<T>} args\n * @returns {args is Args<WithServerSubcommand>}\n */\nfunction areServerCommandArgs(args) {\n  return args.subcommand === SERVER_SUBCOMMAND;\n}\n\n/**\n * Initializes Appium, but does not start the server.\n *\n * Use this to get at the configuration schema.\n *\n * If `args` contains a non-empty `subcommand` which is not `server`, this function will return an empty object.\n *\n * @template [T=WithServerSubcommand]\n * @param {Args<T>} [args] - Partial args (progammatic usage only)\n * @returns {Promise<ServerInitResult | ExtCommandInitResult>}\n * @example\n * import {init, getSchema} from 'appium';\n * const options = {}; // config object\n * await init(options);\n * const schema = getSchema(); // entire config schema including plugins and drivers\n */\nasync function init(args) {\n  const appiumHome = args?.appiumHome ?? (await resolveAppiumHome());\n\n  const {driverConfig, pluginConfig} = await loadExtensions(appiumHome);\n\n  const parser = getParser();\n  let throwInsteadOfExit = false;\n  /** @type {Args<T>} */\n  let preConfigArgs;\n\n  if (args) {\n    // if we have a containing package instead of running as a CLI process,\n    // that package might not appreciate us calling 'process.exit' willy-\n    // nilly, so give it the option to have us throw instead of exit\n    if (args.throwInsteadOfExit) {\n      throwInsteadOfExit = true;\n      // but remove it since it's not a real server arg per se\n      delete args.throwInsteadOfExit;\n    }\n    preConfigArgs = {...args, subcommand: args.subcommand ?? SERVER_SUBCOMMAND};\n  } else {\n    // otherwise parse from CLI\n    preConfigArgs = /** @type {Args<T>} */ (parser.parseArgs());\n  }\n\n  const configResult = await readConfigFile(preConfigArgs.configFile);\n\n  if (!_.isEmpty(configResult.errors)) {\n    throw new Error(\n      `Errors in config file ${configResult.filepath}:\\n ${\n        configResult.reason ?? configResult.errors\n      }`\n    );\n  }\n\n  // merge config and apply defaults.\n  // the order of precendece is:\n  // 1. command line args\n  // 2. config file\n  // 3. defaults from config file.\n  if (!areServerCommandArgs(preConfigArgs)) {\n    // if the user has requested the 'driver' CLI, don't run the normal server,\n    // but instead pass control to the driver CLI\n    if (preConfigArgs.subcommand === DRIVER_TYPE) {\n      await runExtensionCommand(preConfigArgs, driverConfig);\n      return {};\n    }\n    if (preConfigArgs.subcommand === PLUGIN_TYPE) {\n      await runExtensionCommand(preConfigArgs, pluginConfig);\n      return {};\n    }\n    /* istanbul ignore next */\n    return {}; // should never happen\n  } else {\n    const defaults = getDefaultsForSchema(false);\n\n    /** @type {ParsedArgs} */\n    const serverArgs = _.defaultsDeep(preConfigArgs, configResult.config?.server, defaults);\n\n    if (preConfigArgs.showConfig) {\n      showConfig(getNonDefaultServerArgs(preConfigArgs), configResult, defaults, serverArgs);\n      return {};\n    }\n\n    await logsinkInit(serverArgs);\n\n    if (serverArgs.logFilters) {\n      const {issues, rules} = await logFactory.loadSecureValuesPreprocessingRules(\n        serverArgs.logFilters\n      );\n      if (!_.isEmpty(issues)) {\n        throw new Error(\n          `The log filtering rules config '${serverArgs.logFilters}' has issues: ` +\n            JSON.stringify(issues, null, 2)\n        );\n      }\n      if (_.isEmpty(rules)) {\n        logger.warn(\n          `Found no log filtering rules in '${serverArgs.logFilters}'. Is that expected?`\n        );\n      } else {\n        logger.info(\n          `Loaded ${util.pluralize('filtering rule', rules.length, true)} from '${\n            serverArgs.logFilters\n          }'`\n        );\n      }\n    }\n\n    const appiumDriver = new AppiumDriver(serverArgs);\n    // set the config on the umbrella driver so it can match drivers to caps\n    appiumDriver.driverConfig = driverConfig;\n    await preflightChecks(serverArgs, throwInsteadOfExit);\n\n    return /** @type {ServerInitResult} */ ({\n      appiumDriver,\n      parsedArgs: serverArgs,\n      driverConfig,\n      pluginConfig,\n    });\n  }\n}\n\n/**\n * Initializes Appium's config.  Starts server if appropriate and resolves the\n * server instance if so; otherwise resolves w/ `undefined`.\n * @template [T=WithServerSubcommand]\n * @param {Args<T>} [args] - Arguments from CLI or otherwise\n * @returns {Promise<import('@appium/types').AppiumServer|undefined>}\n */\nasync function main(args) {\n  const {appiumDriver, parsedArgs, pluginConfig, driverConfig} = /** @type {ServerInitResult} */ (\n    await init(args)\n  );\n\n  if (!appiumDriver || !parsedArgs || !pluginConfig || !driverConfig) {\n    // if this branch is taken, we've run a different subcommand, so there's nothing\n    // left to do here.\n    return;\n  }\n\n  const pluginClasses = getActivePlugins(pluginConfig, parsedArgs.usePlugins);\n  // set the active plugins on the umbrella driver so it can use them for commands\n  appiumDriver.pluginClasses = pluginClasses;\n\n  await logStartupInfo(parsedArgs);\n  let routeConfiguringFunction = makeRouter(appiumDriver);\n\n  const driverClasses = getActiveDrivers(driverConfig, parsedArgs.useDrivers);\n  const serverUpdaters = getServerUpdaters(driverClasses, pluginClasses);\n  const extraMethodMap = getExtraMethodMap(driverClasses, pluginClasses);\n\n  const serverOpts = {\n    routeConfiguringFunction,\n    port: parsedArgs.port,\n    hostname: parsedArgs.address,\n    allowCors: parsedArgs.allowCors,\n    basePath: parsedArgs.basePath,\n    serverUpdaters,\n    extraMethodMap,\n  };\n  if (parsedArgs.keepAliveTimeout) {\n    serverOpts.keepAliveTimeout = parsedArgs.keepAliveTimeout * 1000;\n  }\n  let server;\n  try {\n    server = await baseServer(serverOpts);\n  } catch (err) {\n    logger.error(\n      `Could not configure Appium server. It's possible that a driver or plugin tried ` +\n        `to update the server and failed. Original error: ${err.message}`\n    );\n    logger.debug(err.stack);\n    return process.exit(1);\n  }\n\n  if (parsedArgs.allowCors) {\n    logger.warn(\n      'You have enabled CORS requests from any host. Be careful not ' +\n        'to visit sites which could maliciously try to start Appium ' +\n        'sessions on your machine'\n    );\n  }\n  appiumDriver.server = server;\n  try {\n    // configure as node on grid, if necessary\n    // falsy values should not cause this to run\n    if (parsedArgs.nodeconfig) {\n      await registerNode(\n        parsedArgs.nodeconfig,\n        parsedArgs.address,\n        parsedArgs.port,\n        parsedArgs.basePath\n      );\n    }\n  } catch (err) {\n    await server.close();\n    throw err;\n  }\n\n  for (const signal of ['SIGINT', 'SIGTERM']) {\n    process.once(signal, async function onSignal() {\n      logger.info(`Received ${signal} - shutting down`);\n      try {\n        await appiumDriver.deleteAllSessions({\n          force: true,\n          reason: `The process has received ${signal} signal`,\n        });\n        await server.close();\n        process.exit(0);\n      } catch (e) {\n        logger.warn(e);\n        process.exit(1);\n      }\n    });\n  }\n\n  logServerPort(parsedArgs.address, parsedArgs.port);\n  driverConfig.print();\n  pluginConfig.print([...pluginClasses.values()]);\n\n  return server;\n}\n\n// NOTE: this is here for backwards compat for any scripts referencing `main.js` directly\n// (more specifically, `build/lib/main.js`)\n// the executable is now `../index.js`, so that module will typically be `require.main`.\nif (require.main === module) {\n  asyncify(main);\n}\n\n// everything below here is intended to be a public API.\nexport {readConfigFile} from './config-file';\nexport {finalizeSchema, getSchema, validate} from './schema/schema';\nexport {main, init, resolveAppiumHome};\n\n/**\n * @typedef {import('@appium/types').DriverType} DriverType\n * @typedef {import('@appium/types').PluginType} PluginType\n * @typedef {import('@appium/types').DriverClass} DriverClass\n * @typedef {import('@appium/types').PluginClass} PluginClass\n * @typedef {import('appium/types').WithServerSubcommand} WithServerSubcommand\n * @typedef {import('./extension').DriverNameMap} DriverNameMap\n * @typedef {import('./extension').PluginNameMap} PluginNameMap\n */\n\n/**\n * Literally an empty object\n * @typedef { {} } ExtCommandInitResult\n */\n\n/**\n * @typedef ServerInitData\n * @property {import('./appium').AppiumDriver} appiumDriver - The Appium driver\n * @property {import('appium/types').ParsedArgs} parsedArgs - The parsed arguments\n */\n\n/**\n * @typedef {ServerInitData & import('./extension').ExtensionConfigs} ServerInitResult\n */\n\n/**\n * @template [T=WithServerSubcommand]\n * @typedef {import('appium/types').Args<T>} Args\n */\n\n/**\n * @template [T=WithServerSubcommand]\n * @typedef {import('appium/types').ParsedArgs<T>} ParsedArgs\n */\n"],"mappings":"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"}

package/build/lib/schema/arg-spec.d.ts

@@ -0,0 +1,143 @@
+/**
+ * The original ID of the Appium config schema.
+ * We use this in the CLI to convert it to `argparse` options.
+ */
+export const APPIUM_CONFIG_SCHEMA_ID: "appium.json";
+/**
+ * The schema prop containing server-related options. Everything in here
+ * is "native" to Appium.
+ * Used by {@link flattenSchema} for transforming the schema into CLI args.
+ */
+export const SERVER_PROP_NAME: "server";
+/**
+ * An `ArgSpec` is a class representing metadata about an argument (or config
+ * option) used for cross-referencing.
+ *
+ * This class has no instance methods, and is basically just a read-only "struct".
+ * @template D
+ */
+export class ArgSpec<D> {
+    /**
+     * Return the schema ID (`$id`) for the **argument** given the parameters.
+     *
+     * If you need the "root" or "base" schema ID, use {@link ArgSpec.toSchemaBaseRef} instead.
+     * @param {string} name - Argument name
+     * @param {ExtensionType} [extType] - Extension type
+     * @param {string} [extName] - Extension name
+     * @returns {string} Schema ID
+     */
+    static toSchemaRef(name: string, extType?: import("../../../types/build").ExtensionType | undefined, extName?: string | undefined): string;
+    /**
+     * Return the schema ID for an extension or the base schema ID.
+     * @param {ExtensionType} [extType] - Extension type
+     * @param {string} [extName] - Extension name
+     */
+    static toSchemaBaseRef(extType?: import("../../../types/build").ExtensionType | undefined, extName?: string | undefined): string;
+    /**
+     * Return the unique ID for the argument given the parameters.
+     * @param {string} name - Argument name
+     * @param {ExtensionType} [extType] - Extension type
+     * @param {string} [extName] - Extension name
+     * @returns {string} Unique ID
+     */
+    static toArg(name: string, extType?: import("../../../types/build").ExtensionType | undefined, extName?: string | undefined): string;
+    /**
+     * Normalizes a raw extension name (not including the type).
+     * @param {string} extName - Extension name
+     * @returns {string} Normalized extension name
+     */
+    static toNormalizedExtName(extName: string): string;
+    /**
+     * When given the root ID of a schema for an extension (`<extType>-<normalizedExtName>.json`) Returns an object containing the extension type and the _normalized_ extension name.
+     * @param {string} schemaId - Root schema ID
+     * @returns { {extType?: ExtensionType, normalizedExtName?: string} }
+     */
+    static extensionInfoFromRootSchemaId(schemaId: string): {
+        extType?: ExtensionType;
+        normalizedExtName?: string;
+    };
+    /**
+     * Creates an `ArgSpec`
+     *
+     * @param {string} name - The canonical name of the argument. Corresponds to a key in a schema's
+     * `properties` property.
+     * @template D
+     * @param {ArgSpecOptions<D>} [opts] - Options
+     * @returns {Readonly<ArgSpec>}
+     */
+    static create<D_1>(name: string, opts?: ArgSpecOptions<D_1> | undefined): Readonly<ArgSpec<any>>;
+    /**
+     * Builds some computed fields and assigns them to the instance.
+     *
+     * Undefined properties are not assigned.
+     *
+     * The _constructor_ is private. Use {@link ArgSpec.create} instead.
+     * @private
+     * @param {string} name
+     * @param {ArgSpecOptions<D>} [opts]
+     */
+    private constructor();
+    /**
+     * The canonical name of the argument. Corresponds to key in schema's `properties` prop.
+     * @type {string}
+     */
+    name: string;
+    /**
+     * The `ExtensionType` of the argument. This will be set if the arg came from an extension;
+     * otherwise it will be `undefined`.
+     * @type {ExtensionType|undefined}
+     */
+    extType: ExtensionType | undefined;
+    /**
+     * The name of the extension, if this argument came from an extension.
+     *
+     * Otherwise `undefined`.
+     * @type {string|undefined}
+     */
+    extName: string | undefined;
+    /**
+     * The schema ID (`$id`) for the argument.  This is automatically determined, and any user-provided `$id`s will be overwritten.
+     *
+     * @type {string}
+     */
+    ref: string;
+    /**
+     * The CLI argument, sans leading dashes.
+     * @type {string}
+     */
+    arg: string;
+    /**
+     * The desired keypath for the argument after arguments have been parsed.
+     *
+     * Typically this is camelCased.  If the arg came from an extension, it will be prefixed with
+     * `<extType>.<extName>.`
+     * @type {string}
+     */
+    dest: string;
+    /**
+     * The same as {@link ArgSpec.dest} but without the leading `<extType>.<extName>.` prefix.
+     */
+    rawDest: string;
+    /**
+     * Whatever the default value of this argument is, as specified by the
+     * `default` property of the schema.
+     * @type {D|undefined}
+     */
+    defaultValue: D | undefined;
+    /**
+     * String representation, useful for debugging
+     * @returns {string}
+     */
+    toString(): string;
+}
+/**
+ * Options for {@link ArgSpec.create }
+ */
+export type ArgSpecOptions<D> = {
+    extName?: string | undefined;
+    extType?: import("../../../types/build").ExtensionType | undefined;
+    dest?: string | undefined;
+    defaultValue?: D | undefined;
+};
+export type ExtensionType = import('../extension/manifest').ExtensionType;
+//# sourceMappingURL=arg-spec.d.ts.map

package/build/lib/schema/arg-spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arg-spec.d.ts","sourceRoot":"","sources":["../../../lib/schema/arg-spec.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,oDAAqD;AAErD;;;;GAIG;AACH,wCAAyC;AAYzC;;;;;;GAMG;AACH;IAyFE;;;;;;;;OAQG;IACH,yBALW,MAAM,qGAGJ,MAAM,CAQlB;IAED;;;;OAIG;IACH,iIAKC;IAED;;;;;;OAMG;IACH,mBALW,MAAM,qGAGJ,MAAM,CAQlB;IAED;;;;OAIG;IACH,oCAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,+CAHW,MAAM,GACH;QAAC,OAAO,CAAC,EAAE,aAAa,CAAC;QAAC,iBAAiB,CAAC,EAAE,MAAM,CAAA;KAAC,CAUlE;IAED;;;;;;;;OAQG;IACH,yBANW,MAAM,2CAIJ,sBAAiB,CAI7B;IAhHD;;;;;;;;;OASG;IACH,sBAqBC;IAtFD;;;OAGG;IACH,MAFU,MAAM,CAEX;IAEL;;;;OAIG;IACH,SAFU,aAAa,GAAC,SAAS,CAEzB;IAER;;;;;OAKG;IACH,SAFU,MAAM,GAAC,SAAS,CAElB;IAER;;;;OAIG;IACH,KAFU,MAAM,CAEZ;IAEJ;;;OAGG;IACH,KAFU,MAAM,CAEZ;IAEJ;;;;;;OAMG;IACH,MAFU,MAAM,CAEX;IAEL;;OAEG;IACH,gBAAQ;IAER;;;;OAIG;IACH,cAFU,CAAC,GAAC,SAAS,CAER;IAoHb;;;OAGG;IAEH,YAHa,MAAM,CASlB;CACF;;;;;;;;;;4BAaY,OAAO,uBAAuB,EAAE,aAAa"}