Make foo: { type: { name: String } } behave the same as { foo: new Schema({ name: String }) }

[vkarpov15]

Re: #7143. Right now the below declarations are different, and its a very subtle footgun that's hard to notice.

// `foo.name` is a string
new Schema({ foo: { name: String } });

// `foo` is mixed
new Schema({ foo: { type: { name: String } } });

Demo using Node shell:

$ node
> const { Schema } = require('mongoose')
undefined
> new Schema({ foo: { type: { name: String } } }).path('foo')
Mixed {
  path: 'foo',
  instance: 'Mixed',
  validators: [],
  setters: [],
  getters: [],
  options: { type: { name: [Function: String] } },
  _index: null,
  [Symbol(mongoose:schema_mixed)]: true }
> new Schema({ foo: { type: { name: String } } }).path('foo.name')
undefined
> 
> 
> new Schema({ foo: { name: String } }).path('foo')
undefined
> new Schema({ foo: { name: String } }).path('foo.name')
SchemaString {
  enumValues: [],
  regExp: null,
  path: 'foo.name',
  instance: 'String',
  validators: [],
  setters: [],
  getters: [],
  options: { type: [Function: String] },
  _index: null }
> 

Anybody have thoughts on this? I'm thinking it makes sense to deprecate this behavior, and make it so that new Schema({ foo: { type: { name: String } } }) makes foo.name a string in Mongoose 6.x.

@lineus @Fonger ?

[lineus]

I agree with this change @vkarpov15. I can't think of a reason why anyone would create a new mixed path like this on purpose.

[mhombach]

Wait... so declaring a schema like in this example:
parent: [{ child1: { type: String, required: true }, child2: { type: String, required: true } }]
Is this a MIXED Type ???
When i want to use subdocuments and not mixed-type, do i need to declare a new schema for each subdocument? I am 90% sure that i read somewhere in the mongoose documenation that both ways are ok and do NOT create mixed-types...

[vkarpov15]

@mhombach no, in that example you get a document array. Examples:

// With below, `parent` will **not** be mixed or array of mixed
parent: { child1: { type: String, required: true }, child2: { type: String, required: true } }
parent: [{ type: { child1: { type: String, required: true }, child2: { type: String, required: true } } }]

// With the below, `parent` will be mixed
parent: { type: { child1: { type: String, required: true }, child2: { type: String, required: true } } }

In other words, this issue only impacts you if you declare a nested path using type or whatever your $typeKey is

[Fonger]

This really makes sense especially for developers using TypeScript. This type definition is very common in TS so this can avoid confusion.