Model.translateAlias doesn't iterate through sub-Schemas if the key wasn't an alias

Do you want to request a feature or report a bug? Bug

What is the current behavior? When using Model.translateAlias, if you have a not aliased key that refers to a sub-schema, it will not be picked up to translate keys further along in the key

If the current behavior is a bug, please provide the steps to reproduce.

• Create a FirstSchema, where the top level field does not have an alias and refers to a SubSchema
• Inside the SubSchema, use aliases
• Perform a model(FirstSchema).translateAlias() and see that the SubSchema keys are not translated

The current translate function uses this iterative loop

// in model.js, Model.translateAlias()
for (const i in fieldKeys) {
      const name = fieldKeys[i];
      if (currentSchema && currentSchema.aliases[name]) {
        alias = currentSchema.aliases[name];
        // Alias found,
        translated.push(alias);
      } else {
        // Alias not found, so treat as un-aliased key
        // This is where this problem is, since we do not push name to alias
        translated.push(name);
      }

      // Check if aliased path is a schema
      // If the key wasn't aliased, we have no way to find the subschema
      if (currentSchema && currentSchema.paths[alias]) {
        currentSchema = currentSchema.paths[alias].schema;
      }
      else
        currentSchema = null;
    }

What is the expected behavior? I propose a one line fix

for (const i in fieldKeys) {
      const name = fieldKeys[i];
      if (currentSchema && currentSchema.aliases[name]) {
        alias = currentSchema.aliases[name];
        // Alias found,
        translated.push(alias);
      } else {
        // Alias not found, so treat as un-aliased key
        // Here
        alias = name;
        translated.push(name);
      }

      // Check if aliased path is a schema
      if (currentSchema && currentSchema.paths[alias]) {
        currentSchema = currentSchema.paths[alias].schema;
      }
      else
        currentSchema = null;
    }

[IslandRhythms]

const mongoose = require('mongoose');

const Syntax = new mongoose.Schema({
    s: { type: String, alias: 'syntax' }
  });

  const Character = mongoose.model('Character', new mongoose.Schema({
    dot: { type: Syntax },
    name: { type: String, alias: '名' },
    bio: {
      age: { type: Number, alias: '年齢' }
    }
  }));

  async function run() {
    await mongoose.connect('mongodb://localhost:27017/', {useNewUrlParser: true,
    useUnifiedTopology: true,});
    await mongoose.connection.dropDatabase();

    let test = await Character.translateAliases({
        _id: '1',
        名: 'Stark',
        年齢: 30,
        'dot.syntax': 'DotSyntax',
        $and: [{ $or: [{ 名: 'Stark' }, { 年齢: 30 }] }, { 'dot.syntax': 'DotSyntax' }]
    });
    console.log(test);
    console.log(test.$and[0].$or);
  }

  run();

[frisbee09]

So to clarify, the dot.syntax should be dot.s? I ran the script and everything else looks fine

Yeah, the Syntax schema has an alias on it that should be observed regardless of where it is on a parent schema’s definition. The test case I gave is a direct edit of the test case that already exists in model.translateAliases.test.js to remove the alias of d to dot. This then prevents the syntax > s alias from resolving.