appium 2.0.0-beta.3 → 2.0.0-beta.30

package/build/lib/extension/extension-config.js

@@ -0,0 +1,297 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.INSTALL_TYPE_NPM = exports.INSTALL_TYPE_LOCAL = exports.INSTALL_TYPE_GITHUB = exports.INSTALL_TYPE_GIT = exports.INSTALL_TYPES = exports.ExtensionConfig = void 0;
+
+require("source-map-support/register");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _resolveFrom = _interopRequireDefault(require("resolve-from"));
+
+var _logger = _interopRequireDefault(require("../logger"));
+
+var _schema = require("../schema/schema");
+
+const INSTALL_TYPE_NPM = 'npm';
+exports.INSTALL_TYPE_NPM = INSTALL_TYPE_NPM;
+const INSTALL_TYPE_LOCAL = 'local';
+exports.INSTALL_TYPE_LOCAL = INSTALL_TYPE_LOCAL;
+const INSTALL_TYPE_GITHUB = 'github';
+exports.INSTALL_TYPE_GITHUB = INSTALL_TYPE_GITHUB;
+const INSTALL_TYPE_GIT = 'git';
+exports.INSTALL_TYPE_GIT = INSTALL_TYPE_GIT;
+const INSTALL_TYPES = new Set([INSTALL_TYPE_GIT, INSTALL_TYPE_GITHUB, INSTALL_TYPE_LOCAL, INSTALL_TYPE_NPM]);
+exports.INSTALL_TYPES = INSTALL_TYPES;
+
+class ExtensionConfig {
+  extensionType;
+  configKey;
+  installedExtensions;
+  log;
+  manifest;
+
+  constructor(extensionType, manifest, logFn) {
+    const logger = _lodash.default.isFunction(logFn) ? logFn : _logger.default.error.bind(_logger.default);
+    this.extensionType = extensionType;
+    this.configKey = `${extensionType}s`;
+    this.installedExtensions = manifest.getExtensionData(extensionType);
+    this.log = logger;
+    this.manifest = manifest;
+  }
+
+  get manifestPath() {
+    return this.manifest.manifestPath;
+  }
+
+  get appiumHome() {
+    return this.manifest.appiumHome;
+  }
+
+  validate(exts) {
+    const foundProblems = {};
+
+    for (const [extName, extData] of _lodash.default.toPairs(exts)) {
+      foundProblems[extName] = [...this.getGenericConfigProblems(extData, extName), ...this.getConfigProblems(extData), ...this.getSchemaProblems(extData, extName)];
+    }
+
+    const problemSummaries = [];
+
+    for (const [extName, problems] of _lodash.default.toPairs(foundProblems)) {
+      if (_lodash.default.isEmpty(problems)) {
+        continue;
+      }
+
+      delete exts[extName];
+      problemSummaries.push(`${this.extensionType} ${extName} had errors and will not ` + `be available. Errors:`);
+
+      for (const problem of problems) {
+        problemSummaries.push(`  - ${problem.err} (Actual value: ` + `${JSON.stringify(problem.val)})`);
+      }
+    }
+
+    if (!_lodash.default.isEmpty(problemSummaries)) {
+      this.log(`Appium encountered one or more errors while validating ` + `the ${this.configKey} extension file (${this.manifestPath}):`);
+
+      for (const summary of problemSummaries) {
+        this.log(summary);
+      }
+    }
+
+    return exts;
+  }
+
+  getSchemaProblems(extData, extName) {
+    const problems = [];
+    const {
+      schema: argSchemaPath
+    } = extData;
+
+    if (ExtensionConfig.extDataHasSchema(extData)) {
+      if (_lodash.default.isString(argSchemaPath)) {
+        if ((0, _schema.isAllowedSchemaFileExtension)(argSchemaPath)) {
+          try {
+            this.readExtensionSchema(extName, extData);
+          } catch (err) {
+            problems.push({
+              err: `Unable to register schema at path ${argSchemaPath}; ${err.message}`,
+              val: argSchemaPath
+            });
+          }
+        } else {
+          problems.push({
+            err: `Schema file has unsupported extension. Allowed: ${[..._schema.ALLOWED_SCHEMA_EXTENSIONS].join(', ')}`,
+            val: argSchemaPath
+          });
+        }
+      } else if (_lodash.default.isPlainObject(argSchemaPath)) {
+        try {
+          this.readExtensionSchema(extName, extData);
+        } catch (err) {
+          problems.push({
+            err: `Unable to register embedded schema; ${err.message}`,
+            val: argSchemaPath
+          });
+        }
+      } else {
+        problems.push({
+          err: 'Incorrectly formatted schema field; must be a path to a schema file or a schema object.',
+          val: argSchemaPath
+        });
+      }
+    }
+
+    return problems;
+  }
+
+  getGenericConfigProblems(extData, extName) {
+    const {
+      version,
+      pkgName,
+      installSpec,
+      installType,
+      mainClass
+    } = extData;
+    const problems = [];
+
+    if (!_lodash.default.isString(version)) {
+      problems.push({
+        err: 'Missing or incorrect version',
+        val: version
+      });
+    }
+
+    if (!_lodash.default.isString(pkgName)) {
+      problems.push({
+        err: 'Missing or incorrect NPM package name',
+        val: pkgName
+      });
+    }
+
+    if (!_lodash.default.isString(installSpec)) {
+      problems.push({
+        err: 'Missing or incorrect installation spec',
+        val: installSpec
+      });
+    }
+
+    if (!INSTALL_TYPES.has(installType)) {
+      problems.push({
+        err: 'Missing or incorrect install type',
+        val: installType
+      });
+    }
+
+    if (!_lodash.default.isString(mainClass)) {
+      problems.push({
+        err: 'Missing or incorrect driver class name',
+        val: mainClass
+      });
+    }
+
+    return problems;
+  }
+
+  getConfigProblems(extData) {
+    return [];
+  }
+
+  async addExtension(extName, extData, {
+    write = true
+  } = {}) {
+    this.manifest.addExtension(this.extensionType, extName, extData);
+
+    if (write) {
+      await this.manifest.write();
+    }
+  }
+
+  async updateExtension(extName, extData, {
+    write = true
+  } = {}) {
+    this.installedExtensions[extName] = { ...this.installedExtensions[extName],
+      ...extData
+    };
+
+    if (write) {
+      await this.manifest.write();
+    }
+  }
+
+  async removeExtension(extName, {
+    write = true
+  } = {}) {
+    delete this.installedExtensions[extName];
+
+    if (write) {
+      await this.manifest.write();
+    }
+  }
+
+  print(activeNames) {
+    if (_lodash.default.isEmpty(this.installedExtensions)) {
+      _logger.default.info(`No ${this.configKey} have been installed in ${this.appiumHome}. Use the "appium ${this.extensionType}" ` + 'command to install the one(s) you want to use.');
+
+      return;
+    }
+
+    _logger.default.info(`Available ${this.configKey}:`);
+
+    for (const [extName, extData] of _lodash.default.toPairs(this.installedExtensions)) {
+      _logger.default.info(`  - ${this.extensionDesc(extName, extData)}`);
+    }
+  }
+
+  extensionDesc(extName, extData) {
+    throw new Error('This must be implemented in a subclass');
+  }
+
+  getInstallPath(extName) {
+    return _path.default.join(this.appiumHome, 'node_modules', this.installedExtensions[extName].pkgName);
+  }
+
+  require(extName) {
+    const {
+      mainClass
+    } = this.installedExtensions[extName];
+    const reqPath = this.getInstallPath(extName);
+
+    const reqResolved = require.resolve(reqPath);
+
+    if (process.env.APPIUM_RELOAD_EXTENSIONS && require.cache[reqResolved]) {
+      _logger.default.debug(`Removing ${reqResolved} from require cache`);
+
+      delete require.cache[reqResolved];
+    }
+
+    _logger.default.debug(`Requiring ${this.extensionType} at ${reqPath}`);
+
+    return require(reqPath)[mainClass];
+  }
+
+  isInstalled(extName) {
+    return _lodash.default.includes(Object.keys(this.installedExtensions), extName);
+  }
+
+  static _readExtensionSchema(appiumHome, extType, extName, extData) {
+    const {
+      pkgName,
+      schema: argSchemaPath
+    } = extData;
+
+    if (!argSchemaPath) {
+      throw new TypeError(`No \`schema\` property found in config for ${extType} ${pkgName} -- why is this function being called?`);
+    }
+
+    let moduleObject;
+
+    if (_lodash.default.isString(argSchemaPath)) {
+      const schemaPath = (0, _resolveFrom.default)(appiumHome, _path.default.join(pkgName, argSchemaPath));
+      moduleObject = require(schemaPath);
+    } else {
+      moduleObject = argSchemaPath;
+    }
+
+    const schema = moduleObject.__esModule ? moduleObject.default : moduleObject;
+    (0, _schema.registerSchema)(extType, extName, schema);
+    return schema;
+  }
+
+  static extDataHasSchema(extData) {
+    return _lodash.default.isString(extData === null || extData === void 0 ? void 0 : extData.schema) || _lodash.default.isObject(extData === null || extData === void 0 ? void 0 : extData.schema);
+  }
+
+  readExtensionSchema(extName, extData) {
+    return ExtensionConfig._readExtensionSchema(this.appiumHome, this.extensionType, extName, extData);
+  }
+
+}
+
+exports.ExtensionConfig = ExtensionConfig;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/extension/extension-config.js"],"names":["INSTALL_TYPE_NPM","INSTALL_TYPE_LOCAL","INSTALL_TYPE_GITHUB","INSTALL_TYPE_GIT","INSTALL_TYPES","Set","ExtensionConfig","extensionType","configKey","installedExtensions","log","manifest","constructor","logFn","logger","_","isFunction","error","bind","getExtensionData","manifestPath","appiumHome","validate","exts","foundProblems","extName","extData","toPairs","getGenericConfigProblems","getConfigProblems","getSchemaProblems","problemSummaries","problems","isEmpty","push","problem","err","JSON","stringify","val","summary","schema","argSchemaPath","extDataHasSchema","isString","readExtensionSchema","message","ALLOWED_SCHEMA_EXTENSIONS","join","isPlainObject","version","pkgName","installSpec","installType","mainClass","has","addExtension","write","updateExtension","removeExtension","print","activeNames","info","extensionDesc","Error","getInstallPath","path","require","reqPath","reqResolved","resolve","process","env","APPIUM_RELOAD_EXTENSIONS","cache","debug","isInstalled","includes","Object","keys","_readExtensionSchema","extType","TypeError","moduleObject","schemaPath","__esModule","default","isObject"],"mappings":"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","sourcesContent":["\nimport _ from 'lodash';\nimport path from 'path';\nimport resolveFrom from 'resolve-from';\nimport log from '../logger';\nimport {\n  ALLOWED_SCHEMA_EXTENSIONS,\n  isAllowedSchemaFileExtension,\n  registerSchema,\n} from '../schema/schema';\n\nconst INSTALL_TYPE_NPM = 'npm';\nconst INSTALL_TYPE_LOCAL = 'local';\nconst INSTALL_TYPE_GITHUB = 'github';\nconst INSTALL_TYPE_GIT = 'git';\n\n/** @type {Set<InstallType>} */\nconst INSTALL_TYPES = new Set([\n  INSTALL_TYPE_GIT,\n  INSTALL_TYPE_GITHUB,\n  INSTALL_TYPE_LOCAL,\n  INSTALL_TYPE_NPM,\n]);\n\n/**\n * This class is abstract. It should not be instantiated directly.\n *\n * Subclasses should provide the generic parameter to implement.\n * @template {ExtensionType} ExtType\n */\nexport class ExtensionConfig {\n  /** @type {ExtType} */\n  extensionType;\n\n  /** @type {`${ExtType}s`} */\n  configKey;\n\n  /** @type {ExtRecord<ExtType>} */\n  installedExtensions;\n\n  /** @type {ExtensionLogFn} */\n  log;\n\n  /** @type {Manifest} */\n  manifest;\n\n  /**\n   * @protected\n   * @param {ExtType} extensionType - Type of extension\n   * @param {Manifest} manifest - `Manifest` instance\n   * @param {ExtensionLogFn} [logFn]\n   */\n  constructor (extensionType, manifest, logFn) {\n    const logger = _.isFunction(logFn) ? logFn : log.error.bind(log);\n    this.extensionType = extensionType;\n    this.configKey = `${extensionType}s`;\n    this.installedExtensions = manifest.getExtensionData(extensionType);\n    this.log = logger;\n    this.manifest = manifest;\n  }\n\n  get manifestPath () {\n    return this.manifest.manifestPath;\n  }\n\n  get appiumHome () {\n    return this.manifest.appiumHome;\n  }\n\n  /**\n   * Checks extensions for problems\n   * @param {ExtRecord<ExtType>} exts - Extension data\n   */\n  validate (exts) {\n    const foundProblems =\n      /** @type {Record<ExtName<ExtType>,Problem[]>} */ ({});\n    for (const [\n      extName,\n      extData,\n    ] of /** @type {[ExtName<ExtType>, ExtManifest<ExtType>][]} */ (\n        _.toPairs(exts)\n      )) {\n      foundProblems[extName] = [\n        ...this.getGenericConfigProblems(extData, extName),\n        ...this.getConfigProblems(extData),\n        ...this.getSchemaProblems(extData, extName),\n      ];\n    }\n\n    const problemSummaries = [];\n    for (const [extName, problems] of _.toPairs(foundProblems)) {\n      if (_.isEmpty(problems)) {\n        continue;\n      }\n      // remove this extension from the list since it's not valid\n      delete exts[extName];\n      problemSummaries.push(\n        `${this.extensionType} ${extName} had errors and will not ` +\n          `be available. Errors:`,\n      );\n      for (const problem of problems) {\n        problemSummaries.push(\n          `  - ${problem.err} (Actual value: ` +\n            `${JSON.stringify(problem.val)})`,\n        );\n      }\n    }\n\n    if (!_.isEmpty(problemSummaries)) {\n      this.log(\n        `Appium encountered one or more errors while validating ` +\n          `the ${this.configKey} extension file (${this.manifestPath}):`,\n      );\n      for (const summary of problemSummaries) {\n        this.log(summary);\n      }\n    }\n\n    return exts;\n  }\n\n  /**\n   * @param {ExtManifest<ExtType>} extData\n   * @param {ExtName<ExtType>} extName\n   * @returns {Problem[]}\n   */\n  getSchemaProblems (extData, extName) {\n    const problems = [];\n    const {schema: argSchemaPath} = extData;\n    if (ExtensionConfig.extDataHasSchema(extData)) {\n      if (_.isString(argSchemaPath)) {\n        if (isAllowedSchemaFileExtension(argSchemaPath)) {\n          try {\n            this.readExtensionSchema(extName, extData);\n          } catch (err) {\n            problems.push({\n              err: `Unable to register schema at path ${argSchemaPath}; ${err.message}`,\n              val: argSchemaPath,\n            });\n          }\n        } else {\n          problems.push({\n            err: `Schema file has unsupported extension. Allowed: ${[\n              ...ALLOWED_SCHEMA_EXTENSIONS,\n            ].join(', ')}`,\n            val: argSchemaPath,\n          });\n        }\n      } else if (_.isPlainObject(argSchemaPath)) {\n        try {\n          this.readExtensionSchema(extName, extData);\n        } catch (err) {\n          problems.push({\n            err: `Unable to register embedded schema; ${err.message}`,\n            val: argSchemaPath,\n          });\n        }\n      } else {\n        problems.push({\n          err: 'Incorrectly formatted schema field; must be a path to a schema file or a schema object.',\n          val: argSchemaPath,\n        });\n      }\n    }\n    return problems;\n  }\n\n  /**\n   * @param {ExtManifest<ExtType>} extData\n   * @param {ExtName<ExtType>} extName\n   * @returns {Problem[]}\n   */\n  // eslint-disable-next-line no-unused-vars\n  getGenericConfigProblems (extData, extName) {\n    const {version, pkgName, installSpec, installType, mainClass} =\n      extData;\n    const problems = [];\n\n    if (!_.isString(version)) {\n      problems.push({err: 'Missing or incorrect version', val: version});\n    }\n\n    if (!_.isString(pkgName)) {\n      problems.push({\n        err: 'Missing or incorrect NPM package name',\n        val: pkgName,\n      });\n    }\n\n    if (!_.isString(installSpec)) {\n      problems.push({\n        err: 'Missing or incorrect installation spec',\n        val: installSpec,\n      });\n    }\n\n    if (!INSTALL_TYPES.has(installType)) {\n      problems.push({\n        err: 'Missing or incorrect install type',\n        val: installType,\n      });\n    }\n\n    if (!_.isString(mainClass)) {\n      problems.push({\n        err: 'Missing or incorrect driver class name',\n        val: mainClass,\n      });\n    }\n\n    return problems;\n  }\n\n  /**\n   * @abstract\n   * @param {ExtManifest<ExtType>} extData\n   * @returns {Problem[]}\n   */\n  // eslint-disable-next-line no-unused-vars\n  getConfigProblems (extData) {\n    // shoud override this method if special validation is necessary for this extension type\n    return [];\n  }\n\n  /**\n   * @param {string} extName\n   * @param {ExtManifest<ExtType>} extData\n   * @param {ExtensionConfigMutationOpts} [opts]\n   * @returns {Promise<void>}\n   */\n  async addExtension (extName, extData, {write = true} = {}) {\n    this.manifest.addExtension(this.extensionType, extName, extData);\n    if (write) {\n      await this.manifest.write();\n    }\n  }\n\n  /**\n   * @param {ExtName<ExtType>} extName\n   * @param {ExtManifest<ExtType>|import('../cli/extension-command').ExtensionFields<ExtType>} extData\n   * @param {ExtensionConfigMutationOpts} [opts]\n   * @returns {Promise<void>}\n   */\n  async updateExtension (extName, extData, {write = true} = {}) {\n    this.installedExtensions[extName] = {\n      ...this.installedExtensions[extName],\n      ...extData,\n    };\n    if (write) {\n      await this.manifest.write();\n    }\n  }\n\n  /**\n   * @param {ExtName<ExtType>} extName\n   * @param {ExtensionConfigMutationOpts} [opts]\n   * @returns {Promise<void>}\n   */\n  async removeExtension (extName, {write = true} = {}) {\n    delete this.installedExtensions[extName];\n    if (write) {\n      await this.manifest.write();\n    }\n  }\n\n  /**\n   * @param {ExtName<ExtType>[]} [activeNames]\n   * @returns {void}\n   */\n  // eslint-disable-next-line no-unused-vars\n  print (activeNames) {\n    if (_.isEmpty(this.installedExtensions)) {\n      log.info(\n        `No ${this.configKey} have been installed in ${this.appiumHome}. Use the \"appium ${this.extensionType}\" ` +\n          'command to install the one(s) you want to use.',\n      );\n      return;\n    }\n\n    log.info(`Available ${this.configKey}:`);\n    for (const [\n      extName,\n      extData,\n    ] of /** @type {[string, ExtManifest<ExtType>][]} */ (\n        _.toPairs(this.installedExtensions)\n      )) {\n      log.info(`  - ${this.extensionDesc(extName, extData)}`);\n    }\n  }\n\n  /**\n   * Returns a string describing the extension. Subclasses must implement.\n   * @param {ExtName<ExtType>} extName - Extension name\n   * @param {ExtManifest<ExtType>} extData - Extension data\n   * @returns {string}\n   * @abstract\n   */\n  // eslint-disable-next-line no-unused-vars\n  extensionDesc (extName, extData) {\n    throw new Error('This must be implemented in a subclass');\n  }\n\n  /**\n   * @param {string} extName\n   * @returns {string}\n   */\n  getInstallPath (extName) {\n    return path.join(this.appiumHome, 'node_modules', this.installedExtensions[extName].pkgName);\n  }\n\n  /**\n   * Loads extension and returns its main class (constructor)\n   * @param {ExtName<ExtType>} extName\n   * @returns {ExtClass<ExtType>}\n   */\n  require (extName) {\n    const {mainClass} = this.installedExtensions[extName];\n    const reqPath = this.getInstallPath(extName);\n    const reqResolved = require.resolve(reqPath);\n    // note: this will only reload the entry point\n    if (process.env.APPIUM_RELOAD_EXTENSIONS && require.cache[reqResolved]) {\n      log.debug(`Removing ${reqResolved} from require cache`);\n      delete require.cache[reqResolved];\n    }\n    log.debug(`Requiring ${this.extensionType} at ${reqPath}`);\n    return require(reqPath)[mainClass];\n  }\n\n  /**\n   * @param {string} extName\n   * @returns {boolean}\n   */\n  isInstalled (extName) {\n    return _.includes(Object.keys(this.installedExtensions), extName);\n  }\n\n  /**\n   * Intended to be called by corresponding instance methods of subclass.\n   * @private\n   * @template {ExtensionType} ExtType\n   * @param {string} appiumHome\n   * @param {ExtType} extType\n   * @param {ExtName<ExtType>} extName - Extension name (unique to its type)\n   * @param {ExtManifestWithSchema<ExtType>} extData - Extension config\n   * @returns {import('ajv').SchemaObject|undefined}\n   */\n  static _readExtensionSchema (appiumHome, extType, extName, extData) {\n    const {pkgName, schema: argSchemaPath} = extData;\n    if (!argSchemaPath) {\n      throw new TypeError(\n        `No \\`schema\\` property found in config for ${extType} ${pkgName} -- why is this function being called?`,\n      );\n    }\n    let moduleObject;\n    if (_.isString(argSchemaPath)) {\n      const schemaPath = resolveFrom(appiumHome, path.join(pkgName, argSchemaPath));\n      moduleObject = require(schemaPath);\n    } else {\n      moduleObject = argSchemaPath;\n    }\n    // this sucks. default exports should be destroyed\n    const schema = moduleObject.__esModule\n      ? moduleObject.default\n      : moduleObject;\n    registerSchema(extType, extName, schema);\n    return schema;\n  }\n\n  /**\n   * Returns `true` if a specific {@link ExtManifest} object has a `schema` prop.\n   * The {@link ExtManifest} object becomes a {@link ExtManifestWithSchema} object.\n   * @template {ExtensionType} ExtType\n   * @param {ExtManifest<ExtType>} extData\n   * @returns {extData is ExtManifestWithSchema<ExtType>}\n   */\n  static extDataHasSchema (extData) {\n    return _.isString(extData?.schema) || _.isObject(extData?.schema);\n  }\n\n  /**\n   * If an extension provides a schema, this will load the schema and attempt to\n   * register it with the schema registrar.\n   * @param {ExtName<ExtType>} extName - Name of extension\n   * @param {ExtManifestWithSchema<ExtType>} extData - Extension data\n   * @returns {import('ajv').SchemaObject|undefined}\n   */\n  readExtensionSchema (extName, extData) {\n    return ExtensionConfig._readExtensionSchema(\n      this.appiumHome,\n      this.extensionType,\n      extName,\n      extData,\n    );\n  }\n}\n\nexport {\n  INSTALL_TYPE_NPM,\n  INSTALL_TYPE_GIT,\n  INSTALL_TYPE_LOCAL,\n  INSTALL_TYPE_GITHUB,\n  INSTALL_TYPES,\n};\n\n/**\n * Config problem\n * @typedef Problem\n * @property {string} err - Error message\n * @property {any} val - Associated value\n */\n\n/**\n * An optional logging function provided to an {@link ExtensionConfig} subclass.\n * @callback ExtensionLogFn\n * @param {...any} args\n * @returns {void}\n */\n\n/**\n * @typedef {import('../../types').ExtensionType} ExtensionType\n * @typedef {import('./manifest').Manifest} Manifest\n */\n\n/**\n * @template T\n * @typedef {import('../../types/appium-manifest').ExtManifest<T>} ExtManifest\n */\n\n/**\n * @template T\n * @typedef {import('../../types/appium-manifest').ExtManifestWithSchema<T>} ExtManifestWithSchema\n */\n\n/**\n * @template T\n * @typedef {import('../../types/appium-manifest').ExtName<T>} ExtName\n */\n\n/**\n * @template T\n * @typedef {import('../../types/extension').ExtClass<T>} ExtClass\n */\n\n/**\n * @template T\n * @typedef {import('../../types/appium-manifest').ExtRecord<T>} ExtRecord\n */\n\n/**\n * Options for various methods in {@link ExtensionConfig}\n * @typedef ExtensionConfigMutationOpts\n * @property {boolean} [write=true] Whether or not to write the manifest to disk after a mutation operation\n */\n\n/**\n * A valid install type\n * @typedef {typeof INSTALL_TYPE_NPM | typeof INSTALL_TYPE_GIT | typeof INSTALL_TYPE_LOCAL | typeof INSTALL_TYPE_GITHUB} InstallType\n */\n"]}

package/build/lib/extension/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Loads extensions and creates `ExtensionConfig` instances.
+ *
+ * - Reads the manifest file, creating if necessary
+ * - Using the parsed extension data, creates/gets the `ExtensionConfig` subclass instances
+ * - Returns these instances
+ *
+ * If `appiumHome` is needed, use `resolveAppiumHome` from the `env` module in `@appium/support`.
+ * @param {string} appiumHome
+ * @returns {Promise<ExtensionConfigs>}
+ */
+export function loadExtensions(appiumHome: string): Promise<ExtensionConfigs>;
+/**
+ * Find any plugin name which has been installed, and which has been requested for activation by
+ * using the --use-plugins flag, and turn each one into its class, so we can send them as objects
+ * to the server init. We also want to send/assign them to the umbrella driver so it can use them
+ * to wrap command execution
+ *
+ * @param {import('./plugin-config').PluginConfig} pluginConfig - a plugin extension config
+ * @param {string[]} usePlugins
+ * @returns {import('../../types').PluginClass[]}
+ */
+export function getActivePlugins(pluginConfig: import('./plugin-config').PluginConfig, usePlugins?: string[]): import('../../types').PluginClass[];
+/**
+ * Find any driver name which has been installed, and turn each one into its class, so we can send
+ * them as objects to the server init in case they need to add methods/routes or update the server.
+ * If the --drivers flag was given, this method only loads the given drivers.
+ *
+ * @param {import('./driver-config').DriverConfig} driverConfig - a driver extension config
+ * @param {string[]} [useDrivers] - optional list of drivers to load
+ */
+export function getActiveDrivers(driverConfig: import('./driver-config').DriverConfig, useDrivers?: string[] | undefined): any[];
+export type ExtensionConfigs = {
+    driverConfig: DriverConfig;
+    pluginConfig: PluginConfig;
+};
+import { DriverConfig } from "./driver-config";
+import { PluginConfig } from "./plugin-config";
+//# sourceMappingURL=index.d.ts.map

package/build/lib/extension/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/extension/index.js"],"names":[],"mappings":"AAQA;;;;;;;;;;GAUG;AACH,2CAHW,MAAM,GACJ,QAAQ,gBAAgB,CAAC,CAYrC;AAED;;;;;;;;;GASG;AACH,+CAJW,OAAO,iBAAiB,EAAE,YAAY,eACtC,MAAM,EAAE,GACN,OAAO,aAAa,EAAE,WAAW,EAAE,CA0B/C;AAED;;;;;;;GAOG;AACH,+CAHW,OAAO,iBAAiB,EAAE,YAAY,4CAuBhD;;kBAIa,YAAY;kBACZ,YAAY"}

package/build/lib/extension/index.js

@@ -0,0 +1,77 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getActiveDrivers = getActiveDrivers;
+exports.getActivePlugins = getActivePlugins;
+exports.loadExtensions = loadExtensions;
+
+require("source-map-support/register");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _constants = require("../constants");
+
+var _logger = _interopRequireDefault(require("../logger"));
+
+var _driverConfig = require("./driver-config");
+
+var _manifest = require("./manifest");
+
+var _pluginConfig = require("./plugin-config");
+
+async function loadExtensions(appiumHome) {
+  var _DriverConfig$getInst, _PluginConfig$getInst;
+
+  const manifest = _manifest.Manifest.getInstance(appiumHome);
+
+  const {
+    drivers,
+    plugins
+  } = await manifest.read();
+  const driverConfig = (_DriverConfig$getInst = _driverConfig.DriverConfig.getInstance(manifest)) !== null && _DriverConfig$getInst !== void 0 ? _DriverConfig$getInst : _driverConfig.DriverConfig.create(manifest, {
+    extData: drivers
+  });
+  const pluginConfig = (_PluginConfig$getInst = _pluginConfig.PluginConfig.getInstance(manifest)) !== null && _PluginConfig$getInst !== void 0 ? _PluginConfig$getInst : _pluginConfig.PluginConfig.create(manifest, {
+    extData: plugins
+  });
+  return {
+    driverConfig,
+    pluginConfig
+  };
+}
+
+function getActivePlugins(pluginConfig, usePlugins = []) {
+  return _lodash.default.compact(Object.keys(pluginConfig.installedExtensions).filter(pluginName => _lodash.default.includes(usePlugins, pluginName) || usePlugins.length === 1 && usePlugins[0] === _constants.USE_ALL_PLUGINS).map(pluginName => {
+    try {
+      _logger.default.info(`Attempting to load plugin ${pluginName}...`);
+
+      const PluginClass = pluginConfig.require(pluginName);
+
+      PluginClass.pluginName = pluginName;
+      return PluginClass;
+    } catch (err) {
+      _logger.default.error(`Could not load plugin '${pluginName}', so it will not be available. Error ` + `in loading the plugin was: ${err.message}`);
+
+      _logger.default.debug(err.stack);
+    }
+  }));
+}
+
+function getActiveDrivers(driverConfig, useDrivers = []) {
+  return _lodash.default.compact(Object.keys(driverConfig.installedExtensions).filter(driverName => _lodash.default.includes(useDrivers, driverName) || useDrivers.length === 0).map(driverName => {
+    try {
+      _logger.default.info(`Attempting to load driver ${driverName}...`);
+
+      return driverConfig.require(driverName);
+    } catch (err) {
+      _logger.default.error(`Could not load driver '${driverName}', so it will not be available. Error ` + `in loading the driver was: ${err.message}`);
+
+      _logger.default.debug(err.stack);
+    }
+  }));
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/extension/index.js"],"names":["loadExtensions","appiumHome","manifest","Manifest","getInstance","drivers","plugins","read","driverConfig","DriverConfig","create","extData","pluginConfig","PluginConfig","getActivePlugins","usePlugins","_","compact","Object","keys","installedExtensions","filter","pluginName","includes","length","USE_ALL_PLUGINS","map","log","info","PluginClass","require","err","error","message","debug","stack","getActiveDrivers","useDrivers","driverName"],"mappings":";;;;;;;;;;;;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAaO,eAAeA,cAAf,CAA+BC,UAA/B,EAA2C;AAAA;;AAChD,QAAMC,QAAQ,GAAGC,mBAASC,WAAT,CAAqBH,UAArB,CAAjB;;AACA,QAAM;AAACI,IAAAA,OAAD;AAAUC,IAAAA;AAAV,MAAqB,MAAMJ,QAAQ,CAACK,IAAT,EAAjC;AACA,QAAMC,YAAY,4BAChBC,2BAAaL,WAAb,CAAyBF,QAAzB,CADgB,yEAEhBO,2BAAaC,MAAb,CAAoBR,QAApB,EAA8B;AAACS,IAAAA,OAAO,EAAEN;AAAV,GAA9B,CAFF;AAGA,QAAMO,YAAY,4BAChBC,2BAAaT,WAAb,CAAyBF,QAAzB,CADgB,yEAEhBW,2BAAaH,MAAb,CAAoBR,QAApB,EAA8B;AAACS,IAAAA,OAAO,EAAEL;AAAV,GAA9B,CAFF;AAGA,SAAO;AAACE,IAAAA,YAAD;AAAeI,IAAAA;AAAf,GAAP;AACD;;AAYM,SAASE,gBAAT,CAA2BF,YAA3B,EAAyCG,UAAU,GAAG,EAAtD,EAA0D;AAC/D,SAAOC,gBAAEC,OAAF,CACLC,MAAM,CAACC,IAAP,CAAYP,YAAY,CAACQ,mBAAzB,EACGC,MADH,CAEKC,UAAD,IACEN,gBAAEO,QAAF,CAAWR,UAAX,EAAuBO,UAAvB,KACCP,UAAU,CAACS,MAAX,KAAsB,CAAtB,IAA2BT,UAAU,CAAC,CAAD,CAAV,KAAkBU,0BAJpD,EAMGC,GANH,CAMQJ,UAAD,IAAgB;AACnB,QAAI;AACFK,sBAAIC,IAAJ,CAAU,6BAA4BN,UAAW,KAAjD;;AACA,YAAMO,WAAW,GAAGjB,YAAY,CAACkB,OAAb,CAAqBR,UAArB,CAApB;;AAEAO,MAAAA,WAAW,CAACP,UAAZ,GAAyBA,UAAzB;AACA,aAAOO,WAAP;AACD,KAND,CAME,OAAOE,GAAP,EAAY;AACZJ,sBAAIK,KAAJ,CACG,0BAAyBV,UAAW,wCAArC,GACG,8BAA6BS,GAAG,CAACE,OAAQ,EAF9C;;AAIAN,sBAAIO,KAAJ,CAAUH,GAAG,CAACI,KAAd;AACD;AACF,GApBH,CADK,CAAP;AAuBD;;AAUM,SAASC,gBAAT,CAA2B5B,YAA3B,EAAyC6B,UAAU,GAAG,EAAtD,EAA0D;AAC/D,SAAOrB,gBAAEC,OAAF,CACLC,MAAM,CAACC,IAAP,CAAYX,YAAY,CAACY,mBAAzB,EACGC,MADH,CAEKiB,UAAD,IACEtB,gBAAEO,QAAF,CAAWc,UAAX,EAAuBC,UAAvB,KAAsCD,UAAU,CAACb,MAAX,KAAsB,CAHlE,EAKGE,GALH,CAKQY,UAAD,IAAgB;AACnB,QAAI;AACFX,sBAAIC,IAAJ,CAAU,6BAA4BU,UAAW,KAAjD;;AACA,aAAO9B,YAAY,CAACsB,OAAb,CAAqBQ,UAArB,CAAP;AACD,KAHD,CAGE,OAAOP,GAAP,EAAY;AACZJ,sBAAIK,KAAJ,CACG,0BAAyBM,UAAW,wCAArC,GACG,8BAA6BP,GAAG,CAACE,OAAQ,EAF9C;;AAIAN,sBAAIO,KAAJ,CAAUH,GAAG,CAACI,KAAd;AACD;AACF,GAhBH,CADK,CAAP;AAmBD","sourcesContent":["\nimport _ from 'lodash';\nimport { USE_ALL_PLUGINS } from '../constants';\nimport log from '../logger';\nimport { DriverConfig } from './driver-config';\nimport { Manifest } from './manifest';\nimport { PluginConfig } from './plugin-config';\n\n/**\n * Loads extensions and creates `ExtensionConfig` instances.\n *\n * - Reads the manifest file, creating if necessary\n * - Using the parsed extension data, creates/gets the `ExtensionConfig` subclass instances\n * - Returns these instances\n *\n * If `appiumHome` is needed, use `resolveAppiumHome` from the `env` module in `@appium/support`.\n * @param {string} appiumHome\n * @returns {Promise<ExtensionConfigs>}\n */\nexport async function loadExtensions (appiumHome) {\n  const manifest = Manifest.getInstance(appiumHome);\n  const {drivers, plugins} = await manifest.read();\n  const driverConfig =\n    DriverConfig.getInstance(manifest) ??\n    DriverConfig.create(manifest, {extData: drivers});\n  const pluginConfig =\n    PluginConfig.getInstance(manifest) ??\n    PluginConfig.create(manifest, {extData: plugins});\n  return {driverConfig, pluginConfig};\n}\n\n/**\n * Find any plugin name which has been installed, and which has been requested for activation by\n * using the --use-plugins flag, and turn each one into its class, so we can send them as objects\n * to the server init. We also want to send/assign them to the umbrella driver so it can use them\n * to wrap command execution\n *\n * @param {import('./plugin-config').PluginConfig} pluginConfig - a plugin extension config\n * @param {string[]} usePlugins\n * @returns {import('../../types').PluginClass[]}\n */\nexport function getActivePlugins (pluginConfig, usePlugins = []) {\n  return _.compact(\n    Object.keys(pluginConfig.installedExtensions)\n      .filter(\n        (pluginName) =>\n          _.includes(usePlugins, pluginName) ||\n          (usePlugins.length === 1 && usePlugins[0] === USE_ALL_PLUGINS),\n      )\n      .map((pluginName) => {\n        try {\n          log.info(`Attempting to load plugin ${pluginName}...`);\n          const PluginClass = pluginConfig.require(pluginName);\n\n          PluginClass.pluginName = pluginName; // store the plugin name on the class so it can be used later\n          return PluginClass;\n        } catch (err) {\n          log.error(\n            `Could not load plugin '${pluginName}', so it will not be available. Error ` +\n              `in loading the plugin was: ${err.message}`,\n          );\n          log.debug(err.stack);\n        }\n      }),\n  );\n}\n\n/**\n * Find any driver name which has been installed, and turn each one into its class, so we can send\n * them as objects to the server init in case they need to add methods/routes or update the server.\n * If the --drivers flag was given, this method only loads the given drivers.\n *\n * @param {import('./driver-config').DriverConfig} driverConfig - a driver extension config\n * @param {string[]} [useDrivers] - optional list of drivers to load\n */\nexport function getActiveDrivers (driverConfig, useDrivers = []) {\n  return _.compact(\n    Object.keys(driverConfig.installedExtensions)\n      .filter(\n        (driverName) =>\n          _.includes(useDrivers, driverName) || useDrivers.length === 0,\n      )\n      .map((driverName) => {\n        try {\n          log.info(`Attempting to load driver ${driverName}...`);\n          return driverConfig.require(driverName);\n        } catch (err) {\n          log.error(\n            `Could not load driver '${driverName}', so it will not be available. Error ` +\n              `in loading the driver was: ${err.message}`,\n          );\n          log.debug(err.stack);\n        }\n      }),\n  );\n}\n\n/**\n * @typedef ExtensionConfigs\n * @property {DriverConfig} driverConfig\n * @property {PluginConfig} pluginConfig\n */\n"]}

package/build/lib/extension/manifest.d.ts

@@ -0,0 +1,174 @@
+/**
+ * Handles reading & writing of extension config files.
+ *
+ * Only one instance of this class exists per value of `APPIUM_HOME`.
+ */
+export class Manifest {
+    /**
+     * Returns a new or existing {@link Manifest} instance, based on the value of `appiumHome`.
+     *
+     * Maintains one instance per value of `appiumHome`.
+     * @param {string} appiumHome - Path to `APPIUM_HOME`
+     * @returns {Manifest}
+     */
+    static getInstance: ((appiumHome: any) => Manifest) & _.MemoizedFunction;
+    /**
+     * Sets internal data to a fresh clone of {@link INITIAL_MANIFEST_DATA}
+     *
+     * Use {@link Manifest.getInstance} instead.
+     * @param {string} appiumHome
+     * @private
+     */
+    private constructor();
+    /**
+     * The entire contents of a parsed YAML extension config file.
+     *
+     * Contains proxies for automatic persistence on disk
+     * @type {ManifestData}
+     * @private
+     */
+    private _data;
+    /**
+     * Path to `APPIUM_HOME`.
+     * @private
+     * @type {Readonly<string>}
+     */
+    private _appiumHome;
+    /**
+     * Path to `extensions.yaml`
+     * @type {string}
+     * Not set until {@link Manifest.read} is called.
+     */
+    _manifestPath: string;
+    /**
+     * Helps avoid writing multiple times.
+     *
+     * If this is `undefined`, calling {@link Manifest.write} will cause it to be
+     * set to a `Promise`. When the call to `write()` is complete, the `Promise`
+     * will resolve and then this value will be set to `undefined`.  Concurrent calls
+     * made while this value is a `Promise` will return the `Promise` itself.
+     * @private
+     * @type {Promise<boolean>|undefined}
+     */
+    private _writing;
+    /**
+     * Helps avoid reading multiple times.
+     *
+     * If this is `undefined`, calling {@link Manifest.read} will cause it to be
+     * set to a `Promise`. When the call to `read()` is complete, the `Promise`
+     * will resolve and then this value will be set to `undefined`.  Concurrent calls
+     * made while this value is a `Promise` will return the `Promise` itself.
+     * @private
+     * @type {Promise<void>|undefined}
+     */
+    private _reading;
+    /**
+     * Searches `APPIUM_HOME` for installed extensions and adds them to the manifest.
+     * @param {SyncWithInstalledExtensionsOpts} opts
+     * @returns {Promise<boolean>} `true` if any extensions were added, `false` otherwise.
+     */
+    syncWithInstalledExtensions({ depthLimit }?: SyncWithInstalledExtensionsOpts): Promise<boolean>;
+    /**
+     * Returns `true` if driver with name `name` is registered.
+     * @param {string} name - Driver name
+     * @returns {boolean}
+     */
+    hasDriver(name: string): boolean;
+    /**
+     * Returns `true` if plugin with name `name` is registered.
+     * @param {string} name - Plugin name
+     * @returns {boolean}
+     */
+    hasPlugin(name: string): boolean;
+    /**
+     * Given a path to a `package.json`, add it as either a driver or plugin to the manifest.
+     *
+     * Will _not_ overwrite existing entries.
+     * @template {ExtensionType} ExtType
+     * @param {ExtPackageJson<ExtType>} pkgJson
+     * @param {string} pkgPath
+     * @returns {boolean} - `true` upon success, `false` if the extension is already registered.
+     */
+    addExtensionFromPackage<ExtType extends import("../../types").ExtensionType>(pkgJson: ExtPackageJson<ExtType>, pkgPath: string): boolean;
+    /**
+     * Adds an extension to the manifest as was installed by the `appium` CLI.  The
+     * `extData`, `extType`, and `extName` have already been determined.
+     *
+     * See {@link Manifest.addExtensionFromPackage} for adding an extension from an on-disk package.
+     * @template {ExtensionType} ExtType
+     * @param {ExtType} extType - `driver` or `plugin`
+     * @param {string} extName - Name of extension
+     * @param {ExtManifest<ExtType>} extData - Extension metadata
+     * @returns {void}
+     */
+    addExtension<ExtType_1 extends import("../../types").ExtensionType>(extType: ExtType_1, extName: string, extData: ExtManifest<ExtType_1>): void;
+    /**
+     * Returns the APPIUM_HOME path
+     */
+    get appiumHome(): string;
+    /**
+     * Returns the path to the manifest file
+     */
+    get manifestPath(): string;
+    /**
+     * Returns extension data for a particular type.
+     *
+     * @template {ExtensionType} ExtType
+     * @param {ExtType} extType
+     * @returns {ExtRecord<ExtType>}
+     */
+    getExtensionData<ExtType_2 extends import("../../types").ExtensionType>(extType: ExtType_2): ExtRecord<ExtType_2>;
+    /**
+     * Reads manifest from disk and _overwrites_ the internal data.
+     *
+     * If the manifest does not exist on disk, an {@link INITIAL_MANIFEST_DATA "empty"} manifest file will be created.
+     *
+     * If `APPIUM_HOME` contains a `package.json` with an `appium` dependency, then a hash of the `package.json` will be taken. If this hash differs from the last hash, the contents of `APPIUM_HOME/node_modules` will be scanned for extensions that may have been installed outside of the `appium` CLI.  Any found extensions will be added to the manifest file, and if so, the manifest file will be written to disk.
+     *
+     * Only one read operation should happen at a time.  This is controlled via the {@link Manifest._reading} property.
+     * @returns {Promise<ManifestData>} The data
+     */
+    read(): Promise<ManifestData>;
+    /**
+     * Ensures {@link Manifest._manifestPath} is set.
+     *
+     * Creates the directory if necessary.
+     * @private
+     * @returns {Promise<string>}
+     */
+    private _setManifestPath;
+    /**
+     * Writes the data if it need s writing.
+     *
+     * If the `schemaRev` prop needs updating, the file will be written.
+     *
+     * @todo If this becomes too much of a bottleneck, throttle it.
+     * @returns {Promise<boolean>} Whether the data was written
+     */
+    write(): Promise<boolean>;
+}
+/**
+ * Type of the string referring to a driver (typically as a key or type string)
+ */
+export type DriverType = import('../../types').DriverType;
+/**
+ * Type of the string referring to a plugin (typically as a key or type string)
+ */
+export type PluginType = import('../../types').PluginType;
+export type SyncWithInstalledExtensionsOpts = {
+    /**
+     * - Maximum depth to recurse into subdirectories
+     */
+    depthLimit?: number | undefined;
+};
+export type ManifestData = import('../../types/appium-manifest').ManifestData;
+export type InternalMetadata = import('../../types/appium-manifest').InternalMetadata;
+export type ExtPackageJson<T> = import('../../types/external-manifest').ExtPackageJson<T>;
+export type ExtManifest<T> = import('../../types/appium-manifest').ExtManifest<T>;
+export type ExtRecord<T> = import('../../types/appium-manifest').ExtRecord<T>;
+/**
+ * Either `driver` or `plugin` rn
+ */
+export type ExtensionType = import('../../types').ExtensionType;
+import _ from "lodash";
+//# sourceMappingURL=manifest.d.ts.map

package/build/lib/extension/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../lib/extension/manifest.js"],"names":[],"mappings":"AAqGA;;;;GAIG;AACH;IA4DE;;;;;;OAMG;IACH,yEAIG;IAvBH;;;;;;OAMG;IACH,sBAGC;IAzDD;;;;;;OAMG;IACH,cAAM;IAEN;;;;OAIG;IACH,oBAAY;IAEZ;;;;OAIG;IACH,eAHU,MAAM,CAGF;IAEd;;;;;;;;;OASG;IACH,iBAAS;IAET;;;;;;;;;OASG;IACH,iBAAS;IA2BT;;;;OAIG;IACH,6CAHW,+BAA+B,GAC7B,QAAQ,OAAO,CAAC,CA0B5B;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,wHAHW,MAAM,GACJ,OAAO,CAsCnB;IAED;;;;;;;;;;OAUG;IACH,iGAJW,MAAM,oCAEJ,IAAI,CAIhB;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;;;OAMG;IACH,kHAEC;IAED;;;;;;;;;OASG;IACH,QAFa,QAAQ,YAAY,CAAC,CAsDjC;IAED;;;;;;OAMG;IACH,yBAaC;IAED;;;;;;;OAOG;IACH,SAFa,QAAQ,OAAO,CAAC,CAoC5B;CACF;;;;yBAIY,OAAO,aAAa,EAAE,UAAU;;;;yBAKhC,OAAO,aAAa,EAAE,UAAU;;;;;;;2BAShC,OAAO,6BAA6B,EAAE,YAAY;+BAClD,OAAO,6BAA6B,EAAE,gBAAgB;gCAKtD,OAAO,+BAA+B,EAAE,cAAc,CAAC,CAAC,CAAC;6BAKzD,OAAO,6BAA6B,EAAE,WAAW,CAAC,CAAC,CAAC;2BAKpD,OAAO,6BAA6B,EAAE,SAAS,CAAC,CAAC,CAAC;;;;4BAKlD,OAAO,aAAa,EAAE,aAAa"}