appium 2.0.0-beta.2 → 2.0.0-beta.20

package/build/lib/schema/cli-transformers.js

@@ -0,0 +1,76 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformers = void 0;
+
+require("source-map-support/register");
+
+var _argparse = require("argparse");
+
+var _fs = require("fs");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+function parseCsvLine(value) {
+  return value.split(',').map(v => v.trim()).filter(Boolean);
+}
+
+function parseCsvFile(value) {
+  return value.split(/\r?\n/).map(v => v.trim()).filter(Boolean).flatMap(parseCsvLine);
+}
+
+const transformers = {
+  csv: value => {
+    let body;
+
+    try {
+      body = (0, _fs.readFileSync)(value, 'utf8');
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        throw new _argparse.ArgumentTypeError(`Could not read file ${body}: ${err.message}`);
+      }
+    }
+
+    try {
+      return body ? parseCsvFile(body) : parseCsvLine(value);
+    } catch (err) {
+      throw new _argparse.ArgumentTypeError('Must be a comma-delimited string, e.g., "foo,bar,baz"');
+    }
+  },
+  json: jsonOrPath => {
+    let json = jsonOrPath;
+    let loadedFromFile = false;
+
+    try {
+      json = (0, _fs.readFileSync)(jsonOrPath, 'utf8');
+      loadedFromFile = true;
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        throw err;
+      }
+    }
+
+    try {
+      const result = JSON.parse(json);
+
+      if (!_lodash.default.isPlainObject(result)) {
+        throw new Error(`'${_lodash.default.truncate(result, {
+          length: 100
+        })}' is not an object`);
+      }
+
+      return result;
+    } catch (e) {
+      const msg = loadedFromFile ? `The provided value of '${jsonOrPath}' must be a valid JSON` : `The provided value must be a valid JSON`;
+      throw new TypeError(`${msg}. Original error: ${e.message}`);
+    }
+  }
+};
+exports.transformers = transformers;require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/build/lib/schema/index.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+require("source-map-support/register");
+
+var _schema = require("./schema");
+
+Object.keys(_schema).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _schema[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _schema[key];
+    }
+  });
+});
+
+var _cliArgs = require("./cli-args");
+
+Object.keys(_cliArgs).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _cliArgs[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _cliArgs[key];
+    }
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImxpYi9zY2hlbWEvaW5kZXguanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7QUFBQTs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTs7QUFDQTs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc2NoZW1hJztcbmV4cG9ydCAqIGZyb20gJy4vY2xpLWFyZ3MnO1xuIl0sImZpbGUiOiJsaWIvc2NoZW1hL2luZGV4LmpzIiwic291cmNlUm9vdCI6Ii4uLy4uLy4uIn0=

package/build/lib/schema/keywords.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.keywords = void 0;
+
+require("source-map-support/register");
+
+var _cliTransformers = require("./cli-transformers");
+
+const keywords = {
+  appiumCliAliases: {
+    keyword: 'appiumCliAliases',
+    metaSchema: {
+      type: 'array',
+      items: {
+        type: 'string',
+        minLength: 1
+      },
+      minItems: 1,
+      uniqueItems: true,
+      description: 'List of aliases for the argument. Aliases shorter than three (3) characters will be prefixed with a single dash; otherwise two (2).'
+    }
+  },
+  appiumCliDest: {
+    keyword: 'appiumCliDest',
+    metaSchema: {
+      type: 'string',
+      minLength: 1,
+      description: 'Name of the associated property in the parsed CLI arguments object'
+    }
+  },
+  appiumCliDescription: {
+    keyword: 'appiumCliDescription',
+    schemaType: 'string',
+    metaSchema: {
+      type: 'string',
+      minLength: 1,
+      description: 'Description to provide in the --help text of the CLI. Overrides `description`'
+    }
+  },
+  appiumCliTransformer: {
+    keyword: 'appiumCliTransformer',
+    metaSchema: {
+      type: 'string',
+      enum: Object.keys(_cliTransformers.transformers),
+      description: 'The name of a custom transformer to run against the value as provided via the CLI.'
+    }
+  },
+  appiumCliIgnore: {
+    keyword: 'appiumCliIgnore',
+    metaSchema: {
+      type: 'boolean',
+      description: 'If `true`, Appium will not provide this property as a CLI argument.'
+    }
+  }
+};
+exports.keywords = keywords;require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/build/lib/schema/schema.js

@@ -0,0 +1,357 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validate = exports.resetSchema = exports.registerSchema = exports.isFinalized = exports.isAllowedSchemaFileExtension = exports.hasArgSpec = exports.getSchema = exports.getDefaultsFromSchema = exports.getArgSpec = exports.flattenSchema = exports.finalizeSchema = exports.SchemaUnknownSchemaError = exports.SchemaNameConflictError = exports.SchemaFinalizationError = exports.ALLOWED_SCHEMA_EXTENSIONS = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+require("source-map-support/register");
+
+var _ajv = _interopRequireDefault(require("ajv"));
+
+var _ajvFormats = _interopRequireDefault(require("ajv-formats"));
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _extensionConfig = require("../extension-config");
+
+var _utils = require("../utils");
+
+var _appiumConfigSchema = _interopRequireDefault(require("./appium-config-schema"));
+
+var _argSpec = require("./arg-spec");
+
+var _keywords = require("./keywords");
+
+const ALLOWED_SCHEMA_EXTENSIONS = new Set(['.json', '.js', '.cjs']);
+exports.ALLOWED_SCHEMA_EXTENSIONS = ALLOWED_SCHEMA_EXTENSIONS;
+
+class AppiumSchema {
+  constructor() {
+    (0, _defineProperty2.default)(this, "_argSpecs", new _utils.ReadonlyMap());
+    (0, _defineProperty2.default)(this, "_registeredSchemas", {
+      [_extensionConfig.DRIVER_TYPE]: new Map(),
+      [_extensionConfig.PLUGIN_TYPE]: new Map()
+    });
+    (0, _defineProperty2.default)(this, "_ajv", void 0);
+    (0, _defineProperty2.default)(this, "_finalizedSchemas", null);
+    this._ajv = AppiumSchema._instantiateAjv();
+  }
+
+  static create() {
+    var _AppiumSchema$_instan;
+
+    const instance = (_AppiumSchema$_instan = AppiumSchema._instance) !== null && _AppiumSchema$_instan !== void 0 ? _AppiumSchema$_instan : new AppiumSchema();
+    AppiumSchema._instance = instance;
+
+    _lodash.default.bindAll(instance, ['finalize', 'flatten', 'getArgSpec', 'getDefaults', 'getSchema', 'hasArgSpec', 'isFinalized', 'registerSchema', 'reset', 'validate']);
+
+    return instance;
+  }
+
+  hasRegisteredSchema(extType, extName) {
+    return this._registeredSchemas[extType].has(extName);
+  }
+
+  isFinalized() {
+    return Boolean(this._finalizedSchemas);
+  }
+
+  finalize() {
+    if (this.isFinalized()) {
+      return this._finalizedSchemas;
+    }
+
+    const ajv = this._ajv;
+
+    const baseSchema = _lodash.default.cloneDeep(_appiumConfigSchema.default);
+
+    const addArgSpecs = (schema, extType, extName) => {
+      for (let [propName, propSchema] of Object.entries(schema)) {
+        const argSpec = _argSpec.ArgSpec.create(propName, {
+          dest: propSchema.appiumCliDest,
+          defaultValue: propSchema.default,
+          extType,
+          extName
+        });
+
+        const {
+          arg
+        } = argSpec;
+
+        this._argSpecs.set(arg, argSpec);
+      }
+    };
+
+    addArgSpecs(_lodash.default.omit(baseSchema.properties.server.properties, [_extensionConfig.DRIVER_TYPE, _extensionConfig.PLUGIN_TYPE]));
+    const finalizedSchemas = {};
+
+    const finalSchema = _lodash.default.reduce(this._registeredSchemas, (baseSchema, extensionSchemas, extType) => {
+      extensionSchemas.forEach((schema, extName) => {
+        const $ref = _argSpec.ArgSpec.toSchemaBaseRef(extType, extName);
+
+        schema.$id = $ref;
+        schema.additionalProperties = false;
+        baseSchema.properties.server.properties[extType].properties[extName] = {
+          $ref,
+          $comment: extName
+        };
+        ajv.validateSchema(schema, true);
+        addArgSpecs(schema.properties, extType, extName);
+        ajv.addSchema(schema, $ref);
+        finalizedSchemas[$ref] = schema;
+      });
+      return baseSchema;
+    }, baseSchema);
+
+    ajv.addSchema(finalSchema, _argSpec.APPIUM_CONFIG_SCHEMA_ID);
+    finalizedSchemas[_argSpec.APPIUM_CONFIG_SCHEMA_ID] = finalSchema;
+    ajv.validateSchema(finalSchema, true);
+    this._finalizedSchemas = finalizedSchemas;
+    return Object.freeze(finalizedSchemas);
+  }
+
+  static _instantiateAjv() {
+    const ajv = (0, _ajvFormats.default)(new _ajv.default({
+      allErrors: true
+    }));
+
+    _lodash.default.forEach(_keywords.keywords, keyword => {
+      ajv.addKeyword(keyword);
+    });
+
+    return ajv;
+  }
+
+  reset() {
+    for (const schemaId of Object.keys((_this$_finalizedSchem = this._finalizedSchemas) !== null && _this$_finalizedSchem !== void 0 ? _this$_finalizedSchem : {})) {
+      var _this$_finalizedSchem;
+
+      this._ajv.removeSchema(schemaId);
+    }
+
+    this._argSpecs = new _utils.ReadonlyMap();
+    this._registeredSchemas = {
+      [_extensionConfig.DRIVER_TYPE]: new Map(),
+      [_extensionConfig.PLUGIN_TYPE]: new Map()
+    };
+    this._finalizedSchemas = null;
+    this._ajv = AppiumSchema._instantiateAjv();
+  }
+
+  registerSchema(extType, extName, schema) {
+    if (!(extType && extName && !_lodash.default.isEmpty(schema))) {
+      throw new TypeError('Expected nonempty extension type, extension name and schema parameters');
+    }
+
+    const normalizedExtName = _lodash.default.kebabCase(extName);
+
+    if (this.hasRegisteredSchema(extType, normalizedExtName)) {
+      if (this._registeredSchemas[extType].get(normalizedExtName) === schema) {
+        return;
+      }
+
+      throw new SchemaNameConflictError(extType, extName);
+    }
+
+    this._ajv.validateSchema(schema, true);
+
+    this._registeredSchemas[extType].set(normalizedExtName, schema);
+  }
+
+  getArgSpec(name, extType, extName) {
+    return this._argSpecs.get(_argSpec.ArgSpec.toArg(name, extType, extName));
+  }
+
+  hasArgSpec(name, extType, extName) {
+    return this._argSpecs.has(_argSpec.ArgSpec.toArg(name, extType, extName));
+  }
+
+  getDefaults() {
+    if (!this.isFinalized()) {
+      throw new SchemaFinalizationError();
+    }
+
+    return [...this._argSpecs.values()].reduce((defaults, {
+      defaultValue,
+      dest
+    }) => {
+      if (!_lodash.default.isUndefined(defaultValue)) {
+        defaults[dest] = defaultValue;
+      }
+
+      return defaults;
+    }, {});
+  }
+
+  flatten() {
+    const schema = this.getSchema();
+    const stack = [{
+      properties: schema.properties,
+      prefix: []
+    }];
+    const flattened = [];
+
+    for (const {
+      properties,
+      prefix
+    } of stack) {
+      const pairs = _lodash.default.toPairs(properties);
+
+      for (const [key, value] of pairs) {
+        const {
+          properties,
+          $ref
+        } = value;
+
+        if (properties) {
+          stack.push({
+            properties,
+            prefix: key === _argSpec.SERVER_PROP_NAME ? [] : [...prefix, key]
+          });
+        } else if ($ref) {
+          let refSchema;
+
+          try {
+            refSchema = this.getSchema($ref);
+          } catch (err) {
+            throw new SchemaUnknownSchemaError($ref);
+          }
+
+          const {
+            normalizedExtName
+          } = _argSpec.ArgSpec.extensionInfoFromRootSchemaId($ref);
+
+          if (!normalizedExtName) {
+            throw new ReferenceError(`Could not determine extension name from schema ID ${$ref}. This is a bug.`);
+          }
+
+          stack.push({
+            properties: refSchema.properties,
+            prefix: [...prefix, key, normalizedExtName]
+          });
+        } else if (key !== _extensionConfig.DRIVER_TYPE && key !== _extensionConfig.PLUGIN_TYPE) {
+          const [extType, extName] = prefix;
+          const argSpec = this.getArgSpec(key, extType, extName);
+
+          if (!argSpec) {
+            throw new ReferenceError(`Unknown argument with key ${key}, extType ${extType} and extName ${extName}. This is a bug.`);
+          }
+
+          flattened.push({
+            schema: _lodash.default.cloneDeep(value),
+            argSpec
+          });
+        }
+      }
+    }
+
+    return flattened;
+  }
+
+  getSchema(ref = _argSpec.APPIUM_CONFIG_SCHEMA_ID) {
+    return this._getValidator(ref).schema;
+  }
+
+  _getValidator(id = _argSpec.APPIUM_CONFIG_SCHEMA_ID) {
+    const validator = this._ajv.getSchema(id);
+
+    if (!validator) {
+      if (id === _argSpec.APPIUM_CONFIG_SCHEMA_ID) {
+        throw new SchemaFinalizationError();
+      } else {
+        throw new SchemaUnknownSchemaError(id);
+      }
+    }
+
+    return validator;
+  }
+
+  validate(value, ref = _argSpec.APPIUM_CONFIG_SCHEMA_ID) {
+    const validator = this._getValidator(ref);
+
+    return !validator(value) && _lodash.default.isArray(validator.errors) ? [...validator.errors] : [];
+  }
+
+  static isAllowedSchemaFileExtension(filename) {
+    return ALLOWED_SCHEMA_EXTENSIONS.has(_path.default.extname(filename));
+  }
+
+}
+
+(0, _defineProperty2.default)(AppiumSchema, "_instance", void 0);
+
+class SchemaFinalizationError extends Error {
+  constructor() {
+    super('Schema not yet finalized; `finalize()` must be called first.');
+    (0, _defineProperty2.default)(this, "code", 'APPIUMERR_SCHEMA_FINALIZATION');
+  }
+
+}
+
+exports.SchemaFinalizationError = SchemaFinalizationError;
+
+class SchemaNameConflictError extends Error {
+  constructor(extType, extName) {
+    super(`Name for ${extType} schema "${extName}" conflicts with an existing schema`);
+    (0, _defineProperty2.default)(this, "code", 'APPIUMERR_SCHEMA_NAME_CONFLICT');
+    (0, _defineProperty2.default)(this, "data", void 0);
+    this.data = {
+      extType,
+      extName
+    };
+  }
+
+}
+
+exports.SchemaNameConflictError = SchemaNameConflictError;
+
+class SchemaUnknownSchemaError extends ReferenceError {
+  constructor(schemaId) {
+    super(`Unknown schema: "${schemaId}"`);
+    (0, _defineProperty2.default)(this, "code", 'APPIUMERR_SCHEMA_UNKNOWN_SCHEMA');
+    (0, _defineProperty2.default)(this, "data", void 0);
+    this.data = {
+      schemaId
+    };
+  }
+
+}
+
+exports.SchemaUnknownSchemaError = SchemaUnknownSchemaError;
+const appiumSchema = AppiumSchema.create();
+const {
+  registerSchema,
+  getArgSpec,
+  hasArgSpec,
+  isFinalized,
+  finalize: finalizeSchema,
+  reset: resetSchema,
+  validate,
+  getSchema,
+  flatten: flattenSchema,
+  getDefaults: getDefaultsFromSchema
+} = appiumSchema;
+exports.getDefaultsFromSchema = getDefaultsFromSchema;
+exports.flattenSchema = flattenSchema;
+exports.getSchema = getSchema;
+exports.validate = validate;
+exports.resetSchema = resetSchema;
+exports.finalizeSchema = finalizeSchema;
+exports.isFinalized = isFinalized;
+exports.hasArgSpec = hasArgSpec;
+exports.getArgSpec = getArgSpec;
+exports.registerSchema = registerSchema;
+const {
+  isAllowedSchemaFileExtension
+} = AppiumSchema;
+exports.isAllowedSchemaFileExtension = isAllowedSchemaFileExtension;require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/schema/schema.js"],"names":["ALLOWED_SCHEMA_EXTENSIONS","Set","AppiumSchema","constructor","ReadonlyMap","DRIVER_TYPE","Map","PLUGIN_TYPE","_ajv","_instantiateAjv","create","instance","_instance","_","bindAll","hasRegisteredSchema","extType","extName","_registeredSchemas","has","isFinalized","Boolean","_finalizedSchemas","finalize","ajv","baseSchema","cloneDeep","appiumConfigSchema","addArgSpecs","schema","propName","propSchema","Object","entries","argSpec","ArgSpec","dest","appiumCliDest","defaultValue","default","arg","_argSpecs","set","omit","properties","server","finalizedSchemas","finalSchema","reduce","extensionSchemas","forEach","$ref","toSchemaBaseRef","$id","additionalProperties","$comment","validateSchema","addSchema","APPIUM_CONFIG_SCHEMA_ID","freeze","Ajv","allErrors","keywords","keyword","addKeyword","reset","schemaId","keys","removeSchema","registerSchema","isEmpty","TypeError","normalizedExtName","kebabCase","get","SchemaNameConflictError","getArgSpec","name","toArg","hasArgSpec","getDefaults","SchemaFinalizationError","values","defaults","isUndefined","flatten","getSchema","stack","prefix","flattened","pairs","toPairs","key","value","push","SERVER_PROP_NAME","refSchema","err","SchemaUnknownSchemaError","extensionInfoFromRootSchemaId","ReferenceError","ref","_getValidator","id","validator","validate","isArray","errors","isAllowedSchemaFileExtension","filename","path","extname","Error","data","appiumSchema","finalizeSchema","resetSchema","flattenSchema","getDefaultsFromSchema"],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Ajv from 'ajv';\nimport addFormats from 'ajv-formats';\nimport _ from 'lodash';\nimport path from 'path';\nimport {DRIVER_TYPE, PLUGIN_TYPE} from '../extension-config';\nimport {ReadonlyMap} from '../utils';\nimport appiumConfigSchema from './appium-config-schema';\nimport {ArgSpec, SERVER_PROP_NAME, APPIUM_CONFIG_SCHEMA_ID} from './arg-spec';\nimport {keywords} from './keywords';\n\n/**\n * Extensions that an extension schema file can have.\n */\nexport const ALLOWED_SCHEMA_EXTENSIONS = new Set(['.json', '.js', '.cjs']);\n\n/**\n * A wrapper around Ajv and schema-related functions.\n *\n * Should have been named Highlander, because _there can only be one_\n */\nclass AppiumSchema {\n  /**\n   * A mapping of unique argument IDs to their corresponding {@link ArgSpec}s.\n   *\n   * An \"argument\" is a CLI argument or a config property.\n   *\n   * Used to provide easy lookups of argument metadata when converting between different representations of those arguments.\n   * @private\n   * @type {ReadonlyMap<string,ArgSpec>}\n   */\n  _argSpecs = new ReadonlyMap();\n\n  /**\n   * A map of extension types to extension names to schema objects.\n   *\n   * This data structure is used to ensure there are no naming conflicts. The schemas\n   * are stored here in memory until the instance is _finalized_.\n   * @private\n   * @type {Record<ExtensionType,Map<string,SchemaObject>>}\n   */\n  _registeredSchemas = {[DRIVER_TYPE]: new Map(), [PLUGIN_TYPE]: new Map()};\n\n  /**\n   * Ajv instance\n   *\n   * @private\n   * @type {Ajv}\n   */\n  _ajv;\n\n  /**\n   * Singleton instance.\n   * @private\n   * @type {AppiumSchema}\n   */\n  static _instance;\n\n  /**\n   * Lookup of schema IDs to finalized schemas.\n   *\n   * This does not include references, but rather the root schemas themselves.\n   * @private\n   * @type {Record<string,StrictSchemaObject>?}\n   */\n  _finalizedSchemas = null;\n\n  /**\n   * Initializes Ajv, adds standard formats and our custom keywords.\n   * @see https://npm.im/ajv-formats\n   * @private\n   */\n  constructor () {\n    this._ajv = AppiumSchema._instantiateAjv();\n  }\n\n  /**\n   * Factory function for {@link AppiumSchema} instances.\n   *\n   * Returns a singleton instance if one exists, otherwise creates a new one.\n   * Binds public methods to the instance.\n   * @returns {AppiumSchema}\n   */\n  static create () {\n    const instance = AppiumSchema._instance ?? new AppiumSchema();\n    AppiumSchema._instance = instance;\n\n    _.bindAll(instance, [\n      'finalize',\n      'flatten',\n      'getArgSpec',\n      'getDefaults',\n      'getSchema',\n      'hasArgSpec',\n      'isFinalized',\n      'registerSchema',\n      'reset',\n      'validate',\n    ]);\n\n    return instance;\n  }\n\n  /**\n   * Returns `true` if a schema has been registered using given extension type and name.\n   *\n   * This does not depend on whether or not the instance has been _finalized_.\n   * @param {ExtensionType} extType - Extension type\n   * @param {string} extName - Name\n   * @returns {boolean} If registered\n   */\n  hasRegisteredSchema (extType, extName) {\n    return this._registeredSchemas[extType].has(extName);\n  }\n\n  /**\n   * Return `true` if {@link AppiumSchema.finalize finalize} has been called\n   * successfully and {@link AppiumSchema.reset reset} has not been called since.\n   * @returns {boolean} If finalized\n   */\n  isFinalized () {\n    return Boolean(this._finalizedSchemas);\n  }\n\n  /**\n   * Call this when no more schemas will be registered.\n   *\n   * This does three things:\n   * 1. It combines all schemas from extensions into the Appium config schema,\n   *    then adds the result to the `Ajv` instance.\n   * 2. It adds schemas for _each_ argument/property for validation purposes.\n   *    The CLI uses these schemas to validate specific arguments.\n   * 3. The schemas are validated against JSON schema draft-07 (which is the\n   *    only one supported at this time)\n   *\n   * Any method in this instance that needs to interact with the `Ajv` instance\n   * will throw if this method has not been called.\n   *\n   * If the instance has already been finalized, this is a no-op.\n   * @public\n   * @throws {Error} If the schema is not valid\n   * @returns {Readonly<Record<string,StrictSchemaObject>>} Record of schema IDs to full schema objects\n   */\n  finalize () {\n    if (this.isFinalized()) {\n      return /** @type {Record<string,StrictSchemaObject>} */ (\n        this._finalizedSchemas\n      );\n    }\n\n    const ajv = this._ajv;\n\n    // Ajv will _mutate_ the schema, so we need to clone it.\n    const baseSchema = _.cloneDeep(/** @type {StrictSchemaObject} */(appiumConfigSchema));\n\n    /**\n     *\n     * @param {SchemaObject} schema\n     * @param {ExtensionType} [extType]\n     * @param {string} [extName]\n     */\n    const addArgSpecs = (schema, extType, extName) => {\n      for (let [propName, propSchema] of Object.entries(schema)) {\n        const argSpec = ArgSpec.create(propName, {\n          dest: propSchema.appiumCliDest,\n          defaultValue: propSchema.default,\n          extType,\n          extName,\n        });\n        const {arg} = argSpec;\n        this._argSpecs.set(arg, argSpec);\n      }\n    };\n\n    addArgSpecs(\n      _.omit(baseSchema.properties.server.properties, [\n        DRIVER_TYPE,\n        PLUGIN_TYPE,\n      ]),\n    );\n\n    /**\n     * @type {Record<string,StrictSchemaObject>}\n     */\n    const finalizedSchemas = {};\n\n    const finalSchema = _.reduce(\n      this._registeredSchemas,\n      /**\n       * @param {typeof baseSchema} baseSchema\n       * @param {Map<string,SchemaObject>} extensionSchemas\n       * @param {ExtensionType} extType\n       */\n      (baseSchema, extensionSchemas, extType) => {\n        extensionSchemas.forEach((schema, extName) => {\n          const $ref = ArgSpec.toSchemaBaseRef(extType, extName);\n          schema.$id = $ref;\n          schema.additionalProperties = false; // this makes `schema` become a `StrictSchemaObject`\n          baseSchema.properties.server.properties[extType].properties[extName] =\n            {$ref, $comment: extName};\n          ajv.validateSchema(schema, true);\n          addArgSpecs(schema.properties, extType, extName);\n          ajv.addSchema(schema, $ref);\n          finalizedSchemas[$ref] = /** @type {StrictSchemaObject} */(schema);\n        });\n        return baseSchema;\n      },\n      baseSchema,\n    );\n\n    ajv.addSchema(finalSchema, APPIUM_CONFIG_SCHEMA_ID);\n    finalizedSchemas[APPIUM_CONFIG_SCHEMA_ID] = finalSchema;\n    ajv.validateSchema(finalSchema, true);\n\n    this._finalizedSchemas = finalizedSchemas;\n    return Object.freeze(finalizedSchemas);\n  }\n\n  /**\n   * Configures and creates an Ajv instance.\n   * @private\n   * @returns {Ajv}\n   */\n  static _instantiateAjv () {\n    const ajv = addFormats(\n      new Ajv({\n        // without this not much validation actually happens\n        allErrors: true,\n      }),\n    );\n\n    // add custom keywords to ajv. see schema-keywords.js\n    _.forEach(keywords, (keyword) => {\n      ajv.addKeyword(keyword);\n    });\n\n    return ajv;\n  }\n\n  /**\n   * Resets this instance to its original state.\n   *\n   * - Removes all added schemas from the `Ajv` instance\n   * - Resets the map of {@link ArgSpec ArgSpecs}\n   * - Resets the map of registered schemas\n   * - Sets the {@link AppiumSchema._finalized _finalized} flag to `false`\n   *\n   * If you need to call {@link AppiumSchema.finalize} again, you'll want to call this first.\n   * @returns {void}\n   */\n  reset () {\n    for (const schemaId of Object.keys(this._finalizedSchemas ?? {})) {\n      this._ajv.removeSchema(schemaId);\n    }\n    this._argSpecs = new ReadonlyMap();\n    this._registeredSchemas = {\n      [DRIVER_TYPE]: new Map(),\n      [PLUGIN_TYPE]: new Map(),\n    };\n    this._finalizedSchemas = null;\n\n    // Ajv seems to have an over-eager cache, so we have to dump the object entirely.\n    this._ajv = AppiumSchema._instantiateAjv();\n  }\n\n  /**\n   * Registers a schema from an extension.\n   *\n   * This is \"fail-fast\" in that the schema will immediately be validated against JSON schema draft-07 _or_ whatever the value of the schema's `$schema` prop is.\n   *\n   * Does _not_ add the schema to the `ajv` instance (this is done by {@link AppiumSchema.finalize}).\n   * @param {import('../ext-config-io').ExtensionType} extType - Extension type\n   * @param {string} extName - Unique extension name for `type`\n   * @param {SchemaObject} schema - Schema object\n   * @throws {SchemaNameConflictError} If the schema is an invalid\n   * @returns {void}\n   */\n  registerSchema (extType, extName, schema) {\n    if (!(extType && extName && !_.isEmpty(schema))) {\n      throw new TypeError(\n        'Expected nonempty extension type, extension name and schema parameters',\n      );\n    }\n\n    const normalizedExtName = _.kebabCase(extName);\n    if (this.hasRegisteredSchema(extType, normalizedExtName)) {\n      if (this._registeredSchemas[extType].get(normalizedExtName) === schema) {\n        return;\n      }\n      throw new SchemaNameConflictError(extType, extName);\n    }\n    this._ajv.validateSchema(schema, true);\n\n    this._registeredSchemas[extType].set(normalizedExtName, schema);\n  }\n\n  /**\n   * Returns a {@link ArgSpec} for the given argument name.\n   * @param {string} name - CLI argument name\n   * @param {ExtensionType} [extType] - Extension type\n   * @param {string} [extName] - Extension name\n   * @returns {ArgSpec|undefined} ArgSpec or `undefined` if not found\n   */\n  getArgSpec (name, extType, extName) {\n    return this._argSpecs.get(ArgSpec.toArg(name, extType, extName));\n  }\n\n  /**\n   * Returns `true` if the instance knows about an argument by the given `name`.\n   * @param {string} name - CLI argument name\n   * @param {ExtensionType} [extType] - Extension type\n   * @param {string} [extName] - Extension name\n   * @returns {boolean} `true` if such an {@link ArgSpec} exists\n   */\n  hasArgSpec (name, extType, extName) {\n    return this._argSpecs.has(ArgSpec.toArg(name, extType, extName));\n  }\n\n  /**\n   * Returns a `Record` of argument \"dest\" strings to default values.\n   *\n   * The \"dest\" string is the property name in object returned by `argparse.ArgumentParser['parse_args']`.\n   * @returns {Record<string,ArgSpec['defaultValue']>}\n   */\n  getDefaults () {\n    if (!this.isFinalized()) {\n      throw new SchemaFinalizationError();\n    }\n    return [...this._argSpecs.values()].reduce(\n      (defaults, {defaultValue, dest}) => {\n        if (!_.isUndefined(defaultValue)) {\n          defaults[dest] = defaultValue;\n        }\n        return defaults;\n      },\n      {},\n    );\n  }\n\n  /**\n   * Flatten schema into an array of `SchemaObject`s and associated\n   * {@link ArgSpec ArgSpecs}.\n   *\n   * Converts nested extension schemas to keys based on the extension type and\n   * name. Used when translating to `argparse` options or getting the list of\n   * default values (see {@link AppiumSchema.getDefaults}) for CLI or otherwise.\n   *\n   * The return value is an intermediate reprsentation used by `cli-args`\n   * module's `toParserArgs`, which converts the finalized schema to parameters\n   * used by `argparse`.\n   * @throws If {@link AppiumSchema.finalize} has not been called yet.\n   * @returns {FlattenedSchema}\n   */\n  flatten () {\n    const schema = this.getSchema();\n\n    /** @type {{properties: SchemaObject, prefix: string[]}[]} */\n    const stack = [{properties: schema.properties, prefix: []}];\n    /** @type {FlattenedSchema} */\n    const flattened = [];\n\n    // this bit is a recursive algorithm rewritten as a for loop.\n    // when we find something we want to traverse, we add it to `stack`\n    for (const {properties, prefix} of stack) {\n      const pairs = _.toPairs(properties);\n      for (const [key, value] of pairs) {\n        const {properties, $ref} = value;\n        if (properties) {\n          stack.push({\n            properties,\n            prefix: key === SERVER_PROP_NAME ? [] : [...prefix, key],\n          });\n        } else if ($ref) {\n          let refSchema;\n          try {\n            refSchema = this.getSchema($ref);\n          } catch (err) {\n            // this can happen if an extension schema supplies a $ref to a non-existent schema\n            throw new SchemaUnknownSchemaError($ref);\n          }\n          const {normalizedExtName} =\n            ArgSpec.extensionInfoFromRootSchemaId($ref);\n          if (!normalizedExtName) {\n            /* istanbul ignore next */\n            throw new ReferenceError(\n              `Could not determine extension name from schema ID ${$ref}. This is a bug.`,\n            );\n          }\n          stack.push({\n            properties: refSchema.properties,\n            prefix: [...prefix, key, normalizedExtName],\n          });\n        } else if (key !== DRIVER_TYPE && key !== PLUGIN_TYPE) {\n          const [extType, extName] = prefix;\n          const argSpec = this.getArgSpec(\n            key,\n            /** @type {ExtensionType} */ (extType),\n            extName,\n          );\n          if (!argSpec) {\n            /* istanbul ignore next */\n            throw new ReferenceError(\n              `Unknown argument with key ${key}, extType ${extType} and extName ${extName}. This is a bug.`,\n            );\n          }\n          flattened.push({schema: _.cloneDeep(value), argSpec});\n        }\n      }\n    }\n\n    return flattened;\n  }\n\n  /**\n   * Retrieves the schema itself\n   * @public\n   * @param {string} [ref] - Schema ID\n   * @throws If the schema has not yet been _finalized_\n   * @returns {SchemaObject}\n   */\n  getSchema (ref = APPIUM_CONFIG_SCHEMA_ID) {\n    return /** @type {SchemaObject} */ (this._getValidator(ref).schema);\n  }\n\n  /**\n   * Retrieves schema validator function from Ajv\n   * @param {string} [id] - Schema ID\n   * @private\n   * @returns {import('ajv').ValidateFunction}\n   */\n  _getValidator (id = APPIUM_CONFIG_SCHEMA_ID) {\n    const validator = this._ajv.getSchema(id);\n    if (!validator) {\n      if (id === APPIUM_CONFIG_SCHEMA_ID) {\n        throw new SchemaFinalizationError();\n      } else {\n        throw new SchemaUnknownSchemaError(id);\n      }\n    }\n    return validator;\n  }\n\n  /**\n   * Given an object, validates it against the Appium config schema.\n   * If errors occur, the returned array will be non-empty.\n   * @param {any} value - The value (hopefully an object) to validate against the schema\n   * @param {string} [ref] - Schema ID or ref.\n   * @public\n   * @returns {import('ajv').ErrorObject[]} Array of errors, if any.\n   */\n  validate (value, ref = APPIUM_CONFIG_SCHEMA_ID) {\n    const validator = /** @type {import('ajv').ValidateFunction} */ (\n      this._getValidator(ref)\n    );\n    return !validator(value) && _.isArray(validator.errors)\n      ? [...validator.errors]\n      : [];\n  }\n\n  /**\n   * Returns `true` if `filename`'s file extension is allowed (in {@link ALLOWED_SCHEMA_EXTENSIONS}).\n   * @param {string} filename\n   * @returns {boolean}\n   */\n  static isAllowedSchemaFileExtension (filename) {\n    return ALLOWED_SCHEMA_EXTENSIONS.has(path.extname(filename));\n  }\n}\n\n/**\n * Thrown when the {@link AppiumSchema} instance has not yet been finalized, but\n * the method called requires it.\n */\nexport class SchemaFinalizationError extends Error {\n  /**\n   * @type {Readonly<string>}\n   */\n  code = 'APPIUMERR_SCHEMA_FINALIZATION';\n\n  constructor () {\n    super('Schema not yet finalized; `finalize()` must be called first.');\n  }\n}\n\n/**\n * Thrown when a \"unique\" schema ID conflicts with an existing schema ID.\n *\n * This is likely going to be caused by attempting to register the same schema twice.\n */\nexport class SchemaNameConflictError extends Error {\n  /**\n   * @type {Readonly<string>}\n   */\n  code = 'APPIUMERR_SCHEMA_NAME_CONFLICT';\n\n  /**\n   * @type {Readonly<{extType: ExtensionType, extName: string}>}\n   */\n  data;\n\n  /**\n   * @param {ExtensionType} extType\n   * @param {string} extName\n   */\n  constructor (extType, extName) {\n    super(\n      `Name for ${extType} schema \"${extName}\" conflicts with an existing schema`,\n    );\n    this.data = {extType, extName};\n  }\n}\n\n/**\n * Thrown when a schema ID was expected, but it doesn't exist on the {@link Ajv} instance.\n */\nexport class SchemaUnknownSchemaError extends ReferenceError {\n  /**\n   * @type {Readonly<string>}\n   */\n  code = 'APPIUMERR_SCHEMA_UNKNOWN_SCHEMA';\n\n  /**\n   * @type {Readonly<{schemaId: string}>}\n   */\n  data;\n\n  /**\n   * @param {string} schemaId\n   */\n  constructor (schemaId) {\n    super(`Unknown schema: \"${schemaId}\"`);\n    this.data = {schemaId};\n  }\n}\n\nconst appiumSchema = AppiumSchema.create();\n\nexport const {\n  registerSchema,\n  getArgSpec,\n  hasArgSpec,\n  isFinalized,\n  finalize: finalizeSchema,\n  reset: resetSchema,\n  validate,\n  getSchema,\n  flatten: flattenSchema,\n  getDefaults: getDefaultsFromSchema,\n} = appiumSchema;\nexport const {isAllowedSchemaFileExtension} = AppiumSchema;\n\n/**\n * @typedef {import('ajv').SchemaObject} SchemaObject\n */\n\n/**\n * @typedef {import('../ext-config-io').ExtensionType} ExtensionType\n */\n\n/**\n * An object having property `additionalProperties: false`\n * @typedef {Object} StrictProp\n * @property {false} additionalProperties\n */\n\n/**\n * A {@link SchemaObject} with `additionalProperties: false`\n * @typedef {SchemaObject & StrictProp} StrictSchemaObject\n */\n\n/**\n * A list of schemas associated with properties and their corresponding {@link ArgSpec} objects.\n *\n * Intermediate data structure used when converting the entire schema down to CLI arguments.\n * @typedef {{schema: SchemaObject, argSpec: ArgSpec}[]} FlattenedSchema\n */\n"],"file":"lib/schema/schema.js","sourceRoot":"../../.."}