appium 2.0.0-beta.3 → 2.0.0-beta.34

package/build/lib/schema/schema.js

@@ -0,0 +1,452 @@
+"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.getDefaultsForSchema = exports.getDefaultsForExtension = exports.getArgSpec = exports.getAllArgSpecs = exports.flattenSchema = exports.finalizeSchema = exports.SchemaUnsupportedSchemaError = exports.SchemaUnknownSchemaError = exports.SchemaNameConflictError = exports.SchemaFinalizationError = exports.RoachHotelMap = exports.ALLOWED_SCHEMA_EXTENSIONS = void 0;
+
+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 _constants = require("../constants");
+
+var _schema = require("@appium/schema");
+
+var _argSpec = require("./arg-spec");
+
+var _keywords = require("./keywords");
+
+class RoachHotelMap extends Map {
+  set(key, value) {
+    if (this.has(key)) {
+      throw new Error(`${key} is already set`);
+    }
+
+    return super.set(key, value);
+  }
+
+  delete(key) {
+    return false;
+  }
+
+  clear() {
+    throw new Error(`Cannot clear RoachHotelMap`);
+  }
+
+}
+
+exports.RoachHotelMap = RoachHotelMap;
+const ALLOWED_SCHEMA_EXTENSIONS = new Set(['.json', '.js', '.cjs']);
+exports.ALLOWED_SCHEMA_EXTENSIONS = ALLOWED_SCHEMA_EXTENSIONS;
+
+class AppiumSchema {
+  _argSpecs = new RoachHotelMap();
+  _registeredSchemas = {
+    [_constants.DRIVER_TYPE]: new Map(),
+    [_constants.PLUGIN_TYPE]: new Map()
+  };
+  _ajv;
+  static _instance;
+  _finalizedSchemas = null;
+
+  constructor() {
+    this._ajv = AppiumSchema._instantiateAjv();
+  }
+
+  static create() {
+    if (!AppiumSchema._instance) {
+      const instance = new AppiumSchema();
+      AppiumSchema._instance = instance;
+
+      _lodash.default.bindAll(instance, ['finalize', 'flatten', 'getAllArgSpecs', 'getArgSpec', 'getDefaults', 'getDefaultsForExtension', 'getSchema', 'hasArgSpec', 'isFinalized', 'registerSchema', 'hasRegisteredSchema', 'reset', 'validate']);
+    }
+
+    return AppiumSchema._instance;
+  }
+
+  hasRegisteredSchema(extType, extName) {
+    return this._registeredSchemas[extType].has(extName);
+  }
+
+  isFinalized() {
+    return Boolean(this._finalizedSchemas);
+  }
+
+  getAllArgSpecs() {
+    return this._argSpecs;
+  }
+
+  finalize() {
+    if (this.isFinalized()) {
+      return this._finalizedSchemas;
+    }
+
+    const ajv = this._ajv;
+
+    const baseSchema = _lodash.default.cloneDeep(_schema.AppiumConfigJsonSchema);
+
+    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, [_constants.DRIVER_TYPE, _constants.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 RoachHotelMap();
+    this._registeredSchemas = {
+      [_constants.DRIVER_TYPE]: new Map(),
+      [_constants.PLUGIN_TYPE]: new Map()
+    };
+    this._finalizedSchemas = null;
+    this._ajv = AppiumSchema._instantiateAjv();
+  }
+
+  registerSchema(extType, extName, schema) {
+    if (!(extType && extName) || _lodash.default.isUndefined(schema)) {
+      throw new TypeError('Expected extension type, extension name, and a defined schema');
+    }
+
+    if (!AppiumSchema.isSupportedSchemaType(schema)) {
+      throw new SchemaUnsupportedSchemaError(schema, extType, extName);
+    }
+
+    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(flatten = true) {
+    if (!this.isFinalized()) {
+      throw new SchemaFinalizationError();
+    }
+
+    const reducer = flatten ? (defaults, {
+      defaultValue,
+      dest
+    }) => {
+      if (!_lodash.default.isUndefined(defaultValue)) {
+        defaults[dest] = defaultValue;
+      }
+
+      return defaults;
+    } : (defaults, {
+      defaultValue,
+      dest
+    }) => {
+      if (!_lodash.default.isUndefined(defaultValue)) {
+        _lodash.default.set(defaults, dest, defaultValue);
+      }
+
+      return defaults;
+    };
+    const retval = {};
+    return [...this._argSpecs.values()].reduce(reducer, retval);
+  }
+
+  getDefaultsForExtension(extType, extName) {
+    if (!this.isFinalized()) {
+      throw new SchemaFinalizationError();
+    }
+
+    const specs = [...this._argSpecs.values()].filter(spec => spec.extType === extType && spec.extName === extName);
+    return specs.reduce((defaults, {
+      defaultValue,
+      rawDest
+    }) => {
+      if (!_lodash.default.isUndefined(defaultValue)) {
+        defaults[rawDest] = 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 !== _constants.DRIVER_TYPE && key !== _constants.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));
+  }
+
+  static isSupportedSchemaType(schema) {
+    return _lodash.default.isPlainObject(schema) && schema.$async !== true;
+  }
+
+}
+
+class SchemaFinalizationError extends Error {
+  code = 'APPIUMERR_SCHEMA_FINALIZATION';
+
+  constructor() {
+    super('Schema not yet finalized; `finalize()` must be called first.');
+  }
+
+}
+
+exports.SchemaFinalizationError = SchemaFinalizationError;
+
+class SchemaNameConflictError extends Error {
+  code = 'APPIUMERR_SCHEMA_NAME_CONFLICT';
+  data;
+
+  constructor(extType, extName) {
+    super(`Name for ${extType} schema "${extName}" conflicts with an existing schema`);
+    this.data = {
+      extType,
+      extName
+    };
+  }
+
+}
+
+exports.SchemaNameConflictError = SchemaNameConflictError;
+
+class SchemaUnknownSchemaError extends ReferenceError {
+  code = 'APPIUMERR_SCHEMA_UNKNOWN_SCHEMA';
+  data;
+
+  constructor(schemaId) {
+    super(`Unknown schema: "${schemaId}"`);
+    this.data = {
+      schemaId
+    };
+  }
+
+}
+
+exports.SchemaUnknownSchemaError = SchemaUnknownSchemaError;
+
+class SchemaUnsupportedSchemaError extends TypeError {
+  code = 'APPIUMERR_SCHEMA_UNSUPPORTED_SCHEMA';
+  data;
+
+  constructor(schema, extType, extName) {
+    super((() => {
+      let msg = `Unsupported schema from ${extType} "${extName}":`;
+
+      if (_lodash.default.isBoolean(schema)) {
+        return `${msg} schema cannot be a boolean`;
+      }
+
+      if (_lodash.default.isPlainObject(schema)) {
+        if (schema.$async) {
+          return `${msg} schema cannot be an async schema`;
+        }
+
+        throw new TypeError(`schema IS supported; this error should not be thrown (this is a bug). value of schema: ${JSON.stringify(schema)}`);
+      }
+
+      return `${msg} schema must be a plain object without a true "$async" property`;
+    })());
+    this.data = {
+      schema,
+      extType,
+      extName
+    };
+  }
+
+}
+
+exports.SchemaUnsupportedSchemaError = SchemaUnsupportedSchemaError;
+const appiumSchema = AppiumSchema.create();
+const {
+  registerSchema,
+  getAllArgSpecs,
+  getArgSpec,
+  hasArgSpec,
+  isFinalized,
+  finalize: finalizeSchema,
+  reset: resetSchema,
+  validate,
+  getSchema,
+  flatten: flattenSchema,
+  getDefaults: getDefaultsForSchema,
+  getDefaultsForExtension
+} = appiumSchema;
+exports.getDefaultsForExtension = getDefaultsForExtension;
+exports.getDefaultsForSchema = getDefaultsForSchema;
+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.getAllArgSpecs = getAllArgSpecs;
+exports.registerSchema = registerSchema;
+const {
+  isAllowedSchemaFileExtension
+} = AppiumSchema;
+exports.isAllowedSchemaFileExtension = isAllowedSchemaFileExtension;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["RoachHotelMap","Map","set","key","value","has","Error","delete","clear","ALLOWED_SCHEMA_EXTENSIONS","Set","AppiumSchema","_argSpecs","_registeredSchemas","DRIVER_TYPE","PLUGIN_TYPE","_ajv","_instance","_finalizedSchemas","constructor","_instantiateAjv","create","instance","_","bindAll","hasRegisteredSchema","extType","extName","isFinalized","Boolean","getAllArgSpecs","finalize","ajv","baseSchema","cloneDeep","AppiumConfigJsonSchema","addArgSpecs","schema","propName","propSchema","Object","entries","argSpec","ArgSpec","dest","appiumCliDest","defaultValue","default","arg","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","isUndefined","TypeError","isSupportedSchemaType","SchemaUnsupportedSchemaError","normalizedExtName","kebabCase","get","SchemaNameConflictError","getArgSpec","name","toArg","hasArgSpec","getDefaults","flatten","SchemaFinalizationError","reducer","defaults","retval","values","getDefaultsForExtension","specs","filter","spec","rawDest","getSchema","stack","prefix","flattened","pairs","toPairs","push","SERVER_PROP_NAME","refSchema","err","SchemaUnknownSchemaError","extensionInfoFromRootSchemaId","ReferenceError","ref","_getValidator","id","validator","validate","isArray","errors","isAllowedSchemaFileExtension","filename","path","extname","isPlainObject","$async","code","data","msg","isBoolean","JSON","stringify","appiumSchema","finalizeSchema","resetSchema","flattenSchema","getDefaultsForSchema"],"sources":["../../../lib/schema/schema.js"],"sourcesContent":["\nimport Ajv from 'ajv';\nimport addFormats from 'ajv-formats';\nimport _ from 'lodash';\nimport path from 'path';\nimport { DRIVER_TYPE, PLUGIN_TYPE } from '../constants';\nimport { AppiumConfigJsonSchema } from '@appium/schema';\nimport { APPIUM_CONFIG_SCHEMA_ID, ArgSpec, SERVER_PROP_NAME } from './arg-spec';\nimport { keywords } from './keywords';\n\n/**\n * Key/value pairs go in... but they don't come out.\n *\n * @template K,V\n * @extends {Map<K,V>}\n */\nexport class RoachHotelMap extends Map {\n  /**\n   * @param {K} key\n   * @param {V} value\n   */\n  set (key, value) {\n    if (this.has(key)) {\n      throw new Error(`${key} is already set`);\n    }\n    return super.set(key, value);\n  }\n\n  /**\n   * @param {K} key\n   */\n  // eslint-disable-next-line no-unused-vars\n  delete (key) {\n    return false;\n  }\n\n  clear () {\n    throw new Error(`Cannot clear RoachHotelMap`);\n  }\n}\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 {RoachHotelMap<string,ArgSpec>}\n   */\n  _argSpecs = new RoachHotelMap();\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    if (!AppiumSchema._instance) {\n      const instance = new AppiumSchema();\n      AppiumSchema._instance = instance;\n      _.bindAll(instance, [\n        'finalize',\n        'flatten',\n        'getAllArgSpecs',\n        'getArgSpec',\n        'getDefaults',\n        'getDefaultsForExtension',\n        'getSchema',\n        'hasArgSpec',\n        'isFinalized',\n        'registerSchema',\n        'hasRegisteredSchema',\n        'reset',\n        'validate',\n      ]);\n    }\n\n    return AppiumSchema._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  getAllArgSpecs () {\n    return this._argSpecs;\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 {NonNullable<typeof this._finalizedSchemas>} */ (\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(AppiumConfigJsonSchema);\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 RoachHotelMap();\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 {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) || _.isUndefined(schema)) {\n      throw new TypeError(\n        'Expected extension type, extension name, and a defined schema',\n      );\n    }\n    if (!AppiumSchema.isSupportedSchemaType(schema)) {\n      throw new SchemaUnsupportedSchemaError(schema, extType, extName);\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\n   * `argparse.ArgumentParser['parse_args']`.\n   * @template {boolean|undefined} Flattened\n   * @param {Flattened} [flatten=true] - If `true`, flattens the returned object\n   * using \"keypath\"-style keys of the format `<extType>.<extName>.<argName>`.\n   * Otherwise, returns a nested object using `extType` and `extName` as\n   * properties. Base arguments (server arguments) are always at the top level.\n   * @returns {DefaultValues<Flattened>}\n   */\n  getDefaults (flatten = /** @type {Flattened} */ (true)) {\n    if (!this.isFinalized()) {\n      throw new SchemaFinalizationError();\n    }\n\n    /**\n     * @private\n     * @callback DefaultReducer\n     * @param {DefaultValues<Flattened>} defaults\n     * @param {ArgSpec} argSpec\n     * @returns {DefaultValues<Flattened>}\n     */\n    /** @type {DefaultReducer} */\n    const reducer = flatten\n      ? (defaults, {defaultValue, dest}) => {\n        if (!_.isUndefined(defaultValue)) {\n          defaults[dest] = defaultValue;\n        }\n        return defaults;\n      }\n      : (defaults, {defaultValue, dest}) => {\n        if (!_.isUndefined(defaultValue)) {\n          _.set(defaults, dest, defaultValue);\n        }\n        return defaults;\n      };\n\n    /** @type {DefaultValues<Flattened>} */\n    const retval = {};\n    return [...this._argSpecs.values()].reduce(reducer, retval);\n  }\n\n  /**\n   * Returns a flattened Record of defaults for a specific extension. Keys will\n   * be of format `<argName>`.\n   * @param {ExtensionType} extType - Extension type\n   * @param {string} extName - Extension name\n   * @returns {Record<string,ArgSpecDefaultValue>}\n   */\n  getDefaultsForExtension (extType, extName) {\n    if (!this.isFinalized()) {\n      throw new SchemaFinalizationError();\n    }\n    const specs = [...this._argSpecs.values()].filter(\n      (spec) => spec.extType === extType && spec.extName === extName,\n    );\n    return specs.reduce((defaults, {defaultValue, rawDest}) => {\n      if (!_.isUndefined(defaultValue)) {\n        defaults[rawDest] = defaultValue;\n      }\n      return defaults;\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 = this._getValidator(ref);\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   * Returns `true` if `schema` is a plain object with a non-true `$async` property.\n   * @param {any} schema - Schema to check\n   * @returns {schema is SchemaObject}\n   */\n  static isSupportedSchemaType (schema) {\n    return _.isPlainObject(schema) && schema.$async !== true;\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\n/**\n * Thrown when a schema is provided, but it's of an unsupported type.\n *\n * \"Valid\" schemas which are unsupported include boolean schemas and async schemas\n * (having a `true` `$async` property).\n */\nexport class SchemaUnsupportedSchemaError extends TypeError {\n  /**\n   * @type {Readonly<string>}\n   */\n  code = 'APPIUMERR_SCHEMA_UNSUPPORTED_SCHEMA';\n\n  /**\n   * @type {Readonly<{schema: any, extType: ExtensionType, extName: string}>}\n   */\n  data;\n\n  /**\n   * @param {any} schema\n   * @param {ExtensionType} extType\n   * @param {string} extName\n   */\n  constructor (schema, extType, extName) {\n    // https://github.com/Microsoft/TypeScript/issues/8277\n    super(\n      (() => {\n        let msg = `Unsupported schema from ${extType} \"${extName}\":`;\n        if (_.isBoolean(schema)) {\n          return `${msg} schema cannot be a boolean`;\n        }\n        if (_.isPlainObject(schema)) {\n          if (schema.$async) {\n            return `${msg} schema cannot be an async schema`;\n          }\n          /* istanbul ignore next */\n          throw new TypeError(\n            `schema IS supported; this error should not be thrown (this is a bug). value of schema: ${JSON.stringify(\n              schema,\n            )}`,\n          );\n        }\n        return `${msg} schema must be a plain object without a true \"$async\" property`;\n      })(),\n    );\n    this.data = {schema, extType, extName};\n  }\n}\n\nconst appiumSchema = AppiumSchema.create();\n\nexport const {\n  registerSchema,\n  getAllArgSpecs,\n  getArgSpec,\n  hasArgSpec,\n  isFinalized,\n  finalize: finalizeSchema,\n  reset: resetSchema,\n  validate,\n  getSchema,\n  flatten: flattenSchema,\n  getDefaults: getDefaultsForSchema,\n  getDefaultsForExtension,\n} = appiumSchema;\nexport const {isAllowedSchemaFileExtension} = AppiumSchema;\n\n/**\n * Appium only supports schemas that are plain objects; not arrays.\n * @typedef {import('ajv').SchemaObject & {[key: number]: never}} SchemaObject\n */\n\n/**\n * @typedef {import('../extension/manifest').ExtensionType} ExtensionType\n */\n\n/**\n * An object having property `additionalProperties: false`\n * @typedef 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\n/**\n * @typedef {ArgSpec['defaultValue']} ArgSpecDefaultValue\n */\n\n/**\n * e.g. `{driver: {foo: 'bar'}}` where `foo` is the arg name and `bar` is the default value.\n * @typedef {Record<string,Record<string,ArgSpecDefaultValue>>} NestedArgSpecDefaultValue\n */\n\n/**\n * Helper type for the return value of {@link AppiumSchema.getDefaults}\n * @template {boolean|undefined} Flattened\n * @typedef {Record<string,Flattened extends true ? ArgSpecDefaultValue : ArgSpecDefaultValue | NestedArgSpecDefaultValue>} DefaultValues\n */\n"],"mappings":"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"}

package/build/lib/utils.d.ts

@@ -0,0 +1,66 @@
+export type ParsedDriverCaps = {
+    desiredCaps: Capabilities;
+    protocol: string;
+    processedJsonwpCapabilities?: any;
+    processedW3CCapabilities?: W3CCapabilities | undefined;
+};
+export type InvalidCaps = {
+    error: Error;
+    protocol: string;
+    desiredCaps?: Partial<import("@wdio/types/build/Capabilities").Capabilities & import("@wdio/types/build/Capabilities").AppiumCapabilities & {
+        [x: string]: any;
+    }> | undefined;
+    processedJsonwpCapabilities?: any;
+    processedW3CCapabilities?: W3CCapabilities | undefined;
+};
+export type W3CCapabilities = import('@appium/types').W3CCapabilities;
+export type Capabilities = import('@appium/types').Capabilities;
+export type AppiumW3CCapabilities = import('@appium/types').AppiumW3CCapabilities;
+/**
+ * Dumps to value to the console using `info` logger.
+ *
+ * @todo May want to force color to be `false` if {@link isStdoutTTY} is `false`.
+ */
+export const inspect: (t1: any) => void;
+/**
+ * Takes the caps that were provided in the request and translates them
+ * into caps that can be used by the inner drivers.
+ *
+ * @param {any} jsonwpCapabilities
+ * @param {W3CCapabilities} w3cCapabilities
+ * @param {import('@appium/types').Constraints} constraints
+ * @param {import('@appium/types').DefaultCapabilitiesConfig} [defaultCapabilities]
+ * @returns {ParsedDriverCaps|InvalidCaps}
+ */
+export function parseCapsForInnerDriver(jsonwpCapabilities: any, w3cCapabilities: W3CCapabilities, constraints?: import('@appium/types').Constraints, defaultCapabilities?: import("@appium/types").DefaultCapabilitiesConfig | undefined): ParsedDriverCaps | InvalidCaps;
+/**
+ * Takes a capabilities objects and prefixes capabilities with `appium:`
+ * @param {Capabilities} caps Desired capabilities object
+ * @returns {AppiumW3CCapabilities}
+ */
+export function insertAppiumPrefixes(caps: Capabilities): AppiumW3CCapabilities;
+export function getPackageVersion(pkgName: any): any;
+/**
+ * Pulls the initial values of Appium settings from the given capabilities argument.
+ * Each setting item must satisfy the following format:
+ * `setting[setting_name]: setting_value`
+ * The capabilities argument itself gets mutated, so it does not contain parsed
+ * settings anymore to avoid further parsing issues.
+ * Check
+ * https://github.com/appium/appium/blob/master/docs/en/advanced-concepts/settings.md
+ * for more details on the available settings.
+ *
+ * @param {?Object} caps - Capabilities dictionary. It is mutated if
+ * one or more settings have been pulled from it
+ * @return {Object} - An empty dictionary if the given caps contains no
+ * setting items or a dictionary containing parsed Appium setting names along with
+ * their values.
+ */
+export function pullSettings(caps: any | null): any;
+/**
+ *
+ * @param {AppiumW3CCapabilities} caps
+ * @returns {Capabilities}
+ */
+export function removeAppiumPrefixes(caps: AppiumW3CCapabilities): Capabilities;
+//# sourceMappingURL=utils.d.ts.map

package/build/lib/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../lib/utils.js"],"names":[],"mappings":";iBAwOc,YAAY;cACZ,MAAM;kCACN,GAAG;;;;WAOH,KAAK;cACL,MAAM;;;;kCAEN,GAAG;;;8BAKJ,OAAO,eAAe,EAAE,eAAe;2BACvC,OAAO,eAAe,EAAE,YAAY;oCACpC,OAAO,eAAe,EAAE,qBAAqB;AA1O1D;;;;GAIG;AACH,wCAOK;AAEL;;;;;;;;;GASG;AACH,4DANW,GAAG,mBACH,eAAe,gBACf,OAAO,eAAe,EAAE,WAAW,wFAEjC,gBAAgB,GAAC,WAAW,CA2FxC;AAED;;;;GAIG;AACH,2CAHW,YAAY,GACV,qBAAqB,CAyBjC;AAyBD,qDAGC;AAED;;;;;;;;;;;;;;;GAeG;AACH,oDAgBC;AA5DD;;;;GAIG;AACH,2CAHW,qBAAqB,GACnB,YAAY,CAaxB"}