appium 2.0.0-beta.46 → 2.0.0-beta.47

package/lib/extension/manifest.js

@@ -8,15 +8,11 @@ import {env, fs} from '@appium/support';
 import _ from 'lodash';
 import path from 'path';
 import YAML from 'yaml';
-import {DRIVER_TYPE, PLUGIN_TYPE} from '../constants';
+import {CURRENT_SCHEMA_REV, DRIVER_TYPE, PLUGIN_TYPE} from '../constants';
 import log from '../logger';
 import {INSTALL_TYPE_NPM} from './extension-config';
 import {packageDidChange} from './package-changed';
-
-/**
- * Current configuration schema revision!
- */
-const CONFIG_SCHEMA_REV = 2;
+import {migrate} from './manifest-migrations';
 
 /**
  * The name of the prop (`drivers`) used in `extensions.yaml` for drivers.
@@ -36,7 +32,7 @@ const CONFIG_DATA_PLUGIN_KEY = `${PLUGIN_TYPE}s`;
 const INITIAL_MANIFEST_DATA = Object.freeze({
   [CONFIG_DATA_DRIVER_KEY]: Object.freeze({}),
   [CONFIG_DATA_PLUGIN_KEY]: Object.freeze({}),
-  schemaRev: CONFIG_SCHEMA_REV,
+  schemaRev: CURRENT_SCHEMA_REV,
 });
 
 /**
@@ -93,23 +89,21 @@ export class Manifest {
    *
    * Contains proxies for automatic persistence on disk
    * @type {ManifestData}
-   * @private
    */
-  _data;
+  #data;
 
   /**
    * Path to `APPIUM_HOME`.
-   * @private
    * @type {Readonly<string>}
    */
-  _appiumHome;
+  #appiumHome;
 
   /**
    * Path to `extensions.yaml`
    * @type {string}
    * Not set until {@link Manifest.read} is called.
    */
-  _manifestPath;
+  #manifestPath;
 
   /**
    * Helps avoid writing multiple times.
@@ -118,10 +112,9 @@ export class Manifest {
    * 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}
    */
-  _writing;
+  #writing;
 
   /**
    * Helps avoid reading multiple times.
@@ -130,10 +123,9 @@ export class Manifest {
    * 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}
    */
-  _reading;
+  #reading;
 
   /**
    * Sets internal data to a fresh clone of {@link INITIAL_MANIFEST_DATA}
@@ -143,8 +135,8 @@ export class Manifest {
    * @private
    */
   constructor(appiumHome) {
-    this._appiumHome = appiumHome;
-    this._data = _.cloneDeep(INITIAL_MANIFEST_DATA);
+    this.#appiumHome = appiumHome;
+    this.#data = _.cloneDeep(INITIAL_MANIFEST_DATA);
   }
 
   /**
@@ -187,14 +179,14 @@ export class Manifest {
      */
     const queue = [
       // look at `package.json` in `APPIUM_HOME` only
-      onMatch(path.join(this._appiumHome, 'package.json')),
+      onMatch(path.join(this.#appiumHome, 'package.json')),
     ];
 
     // add dependencies to the queue
     await new B((resolve, reject) => {
       glob(
         'node_modules/{*,@*/*}/package.json',
-        {cwd: this._appiumHome, silent: true, absolute: true},
+        {cwd: this.#appiumHome, silent: true, absolute: true},
         // eslint-disable-next-line promise/prefer-await-to-callbacks
         (err) => {
           if (err) {
@@ -221,7 +213,7 @@ export class Manifest {
    * @returns {boolean}
    */
   hasDriver(name) {
-    return Boolean(this._data.drivers[name]);
+    return Boolean(this.#data.drivers[name]);
   }
 
   /**
@@ -230,7 +222,7 @@ export class Manifest {
    * @returns {boolean}
    */
   hasPlugin(name) {
-    return Boolean(this._data.plugins[name]);
+    return Boolean(this.#data.plugins[name]);
   }
 
   /**
@@ -254,6 +246,7 @@ export class Manifest {
       appiumVersion: pkgJson.peerDependencies?.appium,
       installType: INSTALL_TYPE_NPM,
       installSpec: `${pkgJson.name}@${pkgJson.version}`,
+      installPath: extensionPath,
     };
 
     if (isDriver(pkgJson)) {
@@ -294,22 +287,22 @@ export class Manifest {
    */
   addExtension(extType, extName, extData) {
     const data = _.clone(extData);
-    this._data[`${extType}s`][extName] = data;
+    this.#data[`${extType}s`][extName] = data;
     return data;
   }
 
   /**
-   * Returns the APPIUM_HOME path
+   * Returns the `APPIUM_HOME` path
    */
   get appiumHome() {
-    return this._appiumHome;
+    return this.#appiumHome;
   }
 
   /**
-   * Returns the path to the manifest file
+   * Returns the path to the manifest file (`extensions.yaml`)
    */
   get manifestPath() {
-    return this._manifestPath;
+    return this.#manifestPath;
   }
 
   /**
@@ -320,7 +313,7 @@ export class Manifest {
    * @returns {ExtRecord<ExtType>}
    */
   getExtensionData(extType) {
-    return this._data[/** @type {string} */ (`${extType}s`)];
+    return this.#data[/** @type {string} */ (`${extType}s`)];
   }
 
   /**
@@ -330,23 +323,23 @@ export class Manifest {
    *
    * 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.
+   * Only one read operation should happen at a time.
    * @returns {Promise<ManifestData>} The data
    */
   async read() {
-    if (this._reading) {
-      await this._reading;
-      return this._data;
+    if (this.#reading) {
+      await this.#reading;
+      return this.#data;
     }
 
-    this._reading = (async () => {
+    this.#reading = (async () => {
       /** @type {ManifestData} */
       let data;
       let isNewFile = false;
-      await this._setManifestPath();
+      await this.#setManifestPath();
       try {
-        log.debug(`Reading ${this._manifestPath}...`);
-        const yaml = await fs.readFile(this._manifestPath, 'utf8');
+        log.debug(`Reading ${this.#manifestPath}...`);
+        const yaml = await fs.readFile(this.#manifestPath, 'utf8');
         data = YAML.parse(yaml);
         log.debug(`Parsed manifest file: ${JSON.stringify(data, null, 2)}`);
       } catch (err) {
@@ -354,10 +347,12 @@ export class Manifest {
           data = _.cloneDeep(INITIAL_MANIFEST_DATA);
           isNewFile = true;
         } else {
-          if (this._manifestPath) {
+          if (this.#manifestPath) {
             throw new Error(
               `Appium had trouble loading the extension installation ` +
-                `cache file (${this._manifestPath}). It may be invalid YAML. Specific error: ${err.message}`
+                `cache file (${this.#manifestPath}). It may be invalid YAML. Specific error: ${
+                  err.message
+                }`
             );
           } else {
             throw new Error(
@@ -367,47 +362,58 @@ export class Manifest {
         }
       }
 
-      this._data = data;
-      let installedExtensionsChanged = false;
+      this.#data = data;
+
+      let shouldWrite = false;
+
+      if ((data.schemaRev ?? 0) < CURRENT_SCHEMA_REV) {
+        log.debug(
+          `Updating manifest schema from rev ${data.schemaRev ?? '(none)'} to ${CURRENT_SCHEMA_REV}`
+        );
+        shouldWrite = await migrate(this, this.#data);
+      }
+
       if (
-        (await env.hasAppiumDependency(this.appiumHome)) &&
-        (await packageDidChange(this.appiumHome))
+        shouldWrite ||
+        ((await env.hasAppiumDependency(this.appiumHome)) &&
+          (await packageDidChange(this.appiumHome)))
       ) {
-        installedExtensionsChanged = await this.syncWithInstalledExtensions();
+        shouldWrite = await this.syncWithInstalledExtensions();
       }
 
-      if (isNewFile || installedExtensionsChanged) {
+      if (isNewFile || shouldWrite) {
         await this.write();
       }
     })();
     try {
-      await this._reading;
-      return this._data;
+      await this.#reading;
+      return this.#data;
     } finally {
-      this._reading = undefined;
+      this.#reading = undefined;
     }
   }
 
   /**
-   * Ensures {@link Manifest._manifestPath} is set.
+   * Ensures the internal manifest path is set.
    *
    * Creates the directory if necessary.
-   * @private
    * @returns {Promise<string>}
    */
-  async _setManifestPath() {
-    if (!this._manifestPath) {
-      this._manifestPath = await env.resolveManifestPath(this._appiumHome);
+  async #setManifestPath() {
+    if (!this.#manifestPath) {
+      this.#manifestPath = await env.resolveManifestPath(this.#appiumHome);
 
       /* istanbul ignore if */
-      if (path.relative(this._appiumHome, this._manifestPath).startsWith('.')) {
+      if (path.relative(this.#appiumHome, this.#manifestPath).startsWith('.')) {
         throw new Error(
-          `Mismatch between location of APPIUM_HOME and manifest file. APPIUM_HOME: ${this.appiumHome}, manifest file: ${this._manifestPath}`
+          `Mismatch between location of APPIUM_HOME and manifest file. APPIUM_HOME: ${
+            this.appiumHome
+          }, manifest file: ${this.#manifestPath}`
         );
       }
     }
 
-    return this._manifestPath;
+    return this.#manifestPath;
   }
 
   /**
@@ -419,34 +425,35 @@ export class Manifest {
    * @returns {Promise<boolean>} Whether the data was written
    */
   async write() {
-    if (this._writing) {
-      return this._writing;
+    if (this.#writing) {
+      return this.#writing;
     }
-    this._writing = (async () => {
-      await this._setManifestPath();
+    this.#writing = (async () => {
+      await this.#setManifestPath();
       try {
-        await fs.mkdirp(path.dirname(this._manifestPath));
+        await fs.mkdirp(path.dirname(this.#manifestPath));
       } catch (err) {
         throw new Error(
           `Appium could not create the directory for the manifest file: ${path.dirname(
-            this._manifestPath
+            this.#manifestPath
           )}. Original error: ${err.message}`
         );
       }
       try {
-        await fs.writeFile(this._manifestPath, YAML.stringify(this._data), 'utf8');
+        await fs.writeFile(this.#manifestPath, YAML.stringify(this.#data), 'utf8');
         return true;
       } catch (err) {
         throw new Error(
-          `Appium could not write to manifest at ${this._manifestPath} using APPIUM_HOME ${this._appiumHome}. ` +
-            `Please ensure it is writable. Original error: ${err.message}`
+          `Appium could not write to manifest at ${this.#manifestPath} using APPIUM_HOME ${
+            this.#appiumHome
+          }. Please ensure it is writable. Original error: ${err.message}`
         );
       }
     })();
     try {
-      return await this._writing;
+      return await this.#writing;
     } finally {
-      this._writing = undefined;
+      this.#writing = undefined;
     }
   }
 }
@@ -472,18 +479,18 @@ export class Manifest {
  */
 
 /**
- * @template T
- * @typedef {import('appium/types').ExtPackageJson<T>} ExtPackageJson
+ * @template {ExtensionType} ExtType
+ * @typedef {import('appium/types').ExtPackageJson<ExtType>} ExtPackageJson
  */
 
 /**
- * @template T
- * @typedef {import('appium/types').ExtManifest<T>} ExtManifest
+ * @template {ExtensionType} ExtType
+ * @typedef {import('appium/types').ExtManifest<ExtType>} ExtManifest
  */
 
 /**
- * @template T
- * @typedef {import('appium/types').ExtRecord<T>} ExtRecord
+ * @template {ExtensionType} ExtType
+ * @typedef {import('appium/types').ExtRecord<ExtType>} ExtRecord
  */
 
 /**

package/lib/extension/plugin-config.js

@@ -72,7 +72,7 @@ export class PluginConfig extends ExtensionConfig {
 
   /**
    *
-   * @param {(keyof PluginRecord)[]} activeNames
+   * @param {(keyof import('appium/types').ExtRecord<PluginType>)[]} activeNames
    * @returns {void}
    */
   print(activeNames) {
@@ -106,7 +106,6 @@ export class PluginConfig extends ExtensionConfig {
  */
 
 /**
- * @typedef {import('appium/types').PluginRecord} PluginRecord
  * @typedef {import('@appium/types').PluginType} PluginType
  * @typedef {import('appium/types').ExtMetadata<PluginType>} PluginMetadata
  * @typedef {import('./manifest').Manifest} Manifest

package/lib/logsink.js

@@ -33,6 +33,8 @@ const npmToWinstonLevels = {
   error: 'error',
 };
 
+const encounteredPrefixes = [];
+
 let log = null;
 let useLocalTimeZone = false;
 
@@ -186,8 +188,21 @@ async function createTransports(args) {
   return transports;
 }
 
+function getColorizedPrefix(prefix) {
+  let prefixId = prefix.split('@')[0].trim();
+  prefixId = prefixId.split(' (')[0].trim();
+  if (encounteredPrefixes.indexOf(prefixId) < 0) {
+    encounteredPrefixes.push(prefixId);
+  }
+  // using a multiple of 16 should cause 16 colors to be created
+  const colorNumber = encounteredPrefixes.indexOf(prefixId) * 16;
+  // use the modulus to cycle around color wheel
+  return `\x1b[38;5;${colorNumber % 256}m${prefix}\x1b[0m`;
+}
+
 async function init(args) {
   npmlog.level = 'silent';
+
   // set de facto param passed to timestamp function
   useLocalTimeZone = args.localTimezone;
 
@@ -205,11 +220,17 @@ async function init(args) {
     let msg = logObj.message;
     if (logObj.prefix) {
       const prefix = `[${logObj.prefix}]`;
-      msg = `${args.logNoColors ? prefix : prefix.magenta} ${msg}`;
-    }
-    log[winstonLevel](msg);
-    if (args.logHandler && _.isFunction(args.logHandler)) {
-      args.logHandler(logObj.level, msg);
+      if (args.logNoColors) {
+        msg = `${prefix} ${msg}`;
+      } if (prefix === '[Appium]') {
+        msg = `${prefix.magenta} ${msg}`;
+      } else {
+        msg = `${getColorizedPrefix(prefix)} ${msg}`;
+      }
+      log[winstonLevel](msg);
+      if (args.logHandler && _.isFunction(args.logHandler)) {
+        args.logHandler(logObj.level, msg);
+      }
     }
   });
 }

package/lib/main.js

@@ -23,10 +23,17 @@ import {
 } from './config';
 import {readConfigFile} from './config-file';
 import {loadExtensions, getActivePlugins, getActiveDrivers} from './extension';
-import {DRIVER_TYPE, PLUGIN_TYPE, SERVER_SUBCOMMAND} from './constants';
+import {SERVER_SUBCOMMAND} from './constants';
 import registerNode from './grid-register';
 import {getDefaultsForSchema, validate} from './schema/schema';
-import {inspect, adjustNodePath} from './utils';
+import {
+  inspect,
+  adjustNodePath,
+  isDriverCommandArgs,
+  isExtensionCommandArgs,
+  isPluginCommandArgs,
+  isServerCommandArgs,
+} from './utils';
 
 const {resolveAppiumHome} = env;
 
@@ -143,16 +150,6 @@ function getExtraMethodMap(driverClasses, pluginClasses) {
     {}
   );
 }
-
-/**
- * @template [T=WithServerSubcommand]
- * @param {Args<T>} args
- * @returns {args is Args<WithServerSubcommand>}
- */
-function areServerCommandArgs(args) {
-  return args.subcommand === SERVER_SUBCOMMAND;
-}
-
 /**
  * Initializes Appium, but does not start the server.
  *
@@ -160,9 +157,10 @@ function areServerCommandArgs(args) {
  *
  * If `args` contains a non-empty `subcommand` which is not `server`, this function will return an empty object.
  *
- * @template [T=WithServerSubcommand]
- * @param {Args<T>} [args] - Partial args (progammatic usage only)
- * @returns {Promise<ServerInitResult | ExtCommandInitResult>}
+ * @template {CliCommand} [Cmd=ServerCommand]
+ * @template {CliExtensionSubcommand|void} [SubCmd=void]
+ * @param {Args<Cmd, SubCmd>} [args] - Partial args (progammatic usage only)
+ * @returns {Promise<InitResult<Cmd>>}
  * @example
  * import {init, getSchema} from 'appium';
  * const options = {}; // config object
@@ -178,7 +176,7 @@ async function init(args) {
 
   const parser = getParser();
   let throwInsteadOfExit = false;
-  /** @type {Args<T>} */
+  /** @type {Args<Cmd, SubCmd>} */
   let preConfigArgs;
 
   if (args) {
@@ -193,7 +191,7 @@ async function init(args) {
     preConfigArgs = {...args, subcommand: args.subcommand ?? SERVER_SUBCOMMAND};
   } else {
     // otherwise parse from CLI
-    preConfigArgs = /** @type {Args<T>} */ (parser.parseArgs());
+    preConfigArgs = /** @type {Args<Cmd, SubCmd>} */ (parser.parseArgs());
   }
 
   const configResult = await readConfigFile(preConfigArgs.configFile);
@@ -211,15 +209,15 @@ async function init(args) {
   // 1. command line args
   // 2. config file
   // 3. defaults from config file.
-  if (areServerCommandArgs(preConfigArgs)) {
+  if (isServerCommandArgs(preConfigArgs)) {
     const defaults = getDefaultsForSchema(false);
 
     /** @type {ParsedArgs} */
-    const serverArgs = _.defaultsDeep(preConfigArgs, configResult.config?.server, defaults);
+    const serverArgs = _.defaultsDeep({}, preConfigArgs, configResult.config?.server, defaults);
 
     if (preConfigArgs.showConfig) {
       showConfig(getNonDefaultServerArgs(preConfigArgs), configResult, defaults, serverArgs);
-      return {};
+      return /** @type {InitResult<Cmd>} */ ({});
     }
 
     await logsinkInit(serverArgs);
@@ -252,49 +250,49 @@ async function init(args) {
     appiumDriver.driverConfig = driverConfig;
     await preflightChecks(serverArgs, throwInsteadOfExit);
 
-    return /** @type {ServerInitResult} */ ({
+    return /** @type {InitResult<Cmd>} */ ({
       appiumDriver,
       parsedArgs: serverArgs,
       driverConfig,
       pluginConfig,
     });
   } else {
-    const extensionCommandArgs = /** @type {Args<import('appium/types').WithExtSubcommand>} */ (
-      preConfigArgs
-    );
-    // if the user has requested the 'driver' CLI, don't run the normal server,
-    // but instead pass control to the driver CLI
-    if (preConfigArgs.subcommand === DRIVER_TYPE) {
-      await runExtensionCommand(extensionCommandArgs, driverConfig);
-      return {};
-    }
-    if (preConfigArgs.subcommand === PLUGIN_TYPE) {
-      await runExtensionCommand(extensionCommandArgs, pluginConfig);
-      return {};
+    if (isExtensionCommandArgs(preConfigArgs)) {
+      // if the user has requested the 'driver' CLI, don't run the normal server,
+      // but instead pass control to the driver CLI
+      if (isDriverCommandArgs(preConfigArgs)) {
+        await runExtensionCommand(preConfigArgs, driverConfig);
+      }
+      if (isPluginCommandArgs(preConfigArgs)) {
+        await runExtensionCommand(preConfigArgs, pluginConfig);
+      }
     }
-    /* istanbul ignore next */
-    return {}; // should never happen
+    return /** @type {InitResult<Cmd>} */ ({});
   }
 }
 
 /**
  * Initializes Appium's config.  Starts server if appropriate and resolves the
  * server instance if so; otherwise resolves w/ `undefined`.
- * @template [T=WithServerSubcommand]
- * @param {Args<T>} [args] - Arguments from CLI or otherwise
- * @returns {Promise<import('@appium/types').AppiumServer|undefined>}
+ * @template {CliCommand} [Cmd=ServerCommand]
+ * @template {CliExtensionSubcommand|void} [SubCmd=void]
+ * @param {Args<Cmd, SubCmd>} [args] - Arguments from CLI or otherwise
+ * @returns {Promise<Cmd extends ServerCommand ? import('@appium/types').AppiumServer : void>}
  */
 async function main(args) {
-  const {appiumDriver, parsedArgs, pluginConfig, driverConfig} = /** @type {ServerInitResult} */ (
-    await init(args)
-  );
+  const initResult = await init(args);
 
-  if (!appiumDriver || !parsedArgs || !pluginConfig || !driverConfig) {
+  if (_.isEmpty(initResult)) {
     // if this branch is taken, we've run a different subcommand, so there's nothing
     // left to do here.
-    return;
+    return /** @type {Cmd extends ServerCommand ? import('@appium/types').AppiumServer : void} */ (
+      undefined
+    );
   }
 
+  const {appiumDriver, pluginConfig, driverConfig, parsedArgs} =
+    /** @type {InitResult<ServerCommand>} */ (initResult);
+
   const pluginClasses = getActivePlugins(pluginConfig, parsedArgs.usePlugins);
   // set the active plugins on the umbrella driver so it can use them for commands
   appiumDriver.pluginClasses = pluginClasses;
@@ -377,7 +375,9 @@ async function main(args) {
   driverConfig.print();
   pluginConfig.print([...pluginClasses.values()]);
 
-  return server;
+  return /** @type {Cmd extends ServerCommand ? import('@appium/types').AppiumServer : void} */ (
+    server
+  );
 }
 
 // NOTE: this is here for backwards compat for any scripts referencing `main.js` directly
@@ -397,7 +397,12 @@ export {main, init, resolveAppiumHome};
  * @typedef {import('@appium/types').PluginType} PluginType
  * @typedef {import('@appium/types').DriverClass} DriverClass
  * @typedef {import('@appium/types').PluginClass} PluginClass
- * @typedef {import('appium/types').WithServerSubcommand} WithServerSubcommand
+ * @typedef {import('appium/types').CliCommand} CliCommand
+ * @typedef {import('appium/types').CliExtensionSubcommand} CliExtensionSubcommand
+ * @typedef {import('appium/types').CliExtensionCommand} CliExtensionCommand
+ * @typedef {import('appium/types').ServerCommand} ServerCommand
+ * @typedef {import('appium/types').DriverCommand} DriverCommand
+ * @typedef {import('appium/types').PluginCommand} PluginCommand
  * @typedef {import('./extension').DriverNameMap} DriverNameMap
  * @typedef {import('./extension').PluginNameMap} PluginNameMap
  */
@@ -414,15 +419,18 @@ export {main, init, resolveAppiumHome};
  */
 
 /**
- * @typedef {ServerInitData & import('./extension').ExtensionConfigs} ServerInitResult
+ * @template {CliCommand} Cmd
+ * @typedef {Cmd extends ServerCommand ? ServerInitData & import('./extension').ExtensionConfigs : ExtCommandInitResult} InitResult
  */
 
 /**
- * @template [T=WithServerSubcommand]
- * @typedef {import('appium/types').Args<T>} Args
+ * @template {CliCommand} [Cmd=ServerCommand]
+ * @template {CliExtensionSubcommand|void} [SubCmd=void]
+ * @typedef {import('appium/types').Args<Cmd, SubCmd>} Args
  */
 
 /**
- * @template [T=WithServerSubcommand]
- * @typedef {import('appium/types').ParsedArgs<T>} ParsedArgs
+ * @template {CliCommand} [Cmd=ServerCommand]
+ * @template {CliExtensionSubcommand|void} [SubCmd=void]
+ * @typedef {import('appium/types').ParsedArgs<Cmd, SubCmd>} ParsedArgs
  */

package/lib/schema/schema.js

@@ -43,6 +43,8 @@ export class RoachHotelMap extends Map {
  */
 export const ALLOWED_SCHEMA_EXTENSIONS = new Set(['.json', '.js', '.cjs']);
 
+const SCHEMA_KEY = '$schema';
+
 /**
  * A wrapper around Ajv and schema-related functions.
  *
@@ -316,7 +318,7 @@ class AppiumSchema {
     }
     const normalizedExtName = _.kebabCase(extName);
     if (this.hasRegisteredSchema(extType, normalizedExtName)) {
-      if (this._registeredSchemas[extType].get(normalizedExtName) === schema) {
+      if (_.isEqual(this._registeredSchemas[extType].get(normalizedExtName), schema)) {
         return;
       }
       throw new SchemaNameConflictError(extType, extName);
@@ -441,6 +443,9 @@ class AppiumSchema {
     for (const {properties, prefix} of stack) {
       const pairs = _.toPairs(properties);
       for (const [key, value] of pairs) {
+        if (key === SCHEMA_KEY) {
+          continue;
+        }
         const {properties, $ref} = value;
         if (properties) {
           stack.push({