1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
'use strict';
const cleanPositionalOperators = require('../schema/cleanPositionalOperators');const get = require('../get');const getDiscriminatorByValue = require('../discriminator/getDiscriminatorByValue');const updatedPathsByArrayFilter = require('../update/updatedPathsByArrayFilter');
/** * Like `schema.path()`, except with a document, because impossible to * determine path type without knowing the embedded discriminator key. * @param {Schema} schema * @param {Object} [update] * @param {Object} [filter] * @param {String} path * @param {Object} [options] * @api private */
module.exports = function getEmbeddedDiscriminatorPath(schema, update, filter, path, options) {  const parts = path.split('.');  let schematype = null;  let type = 'adhocOrUndefined';
  filter = filter || {};  update = update || {};  const arrayFilters = options != null && Array.isArray(options.arrayFilters) ?    options.arrayFilters : [];  const updatedPathsByFilter = updatedPathsByArrayFilter(update);
  for (let i = 0; i < parts.length; ++i) {    const subpath = cleanPositionalOperators(parts.slice(0, i + 1).join('.'));    schematype = schema.path(subpath);    if (schematype == null) {      continue;    }
    type = schema.pathType(subpath);    if ((schematype.$isSingleNested || schematype.$isMongooseDocumentArrayElement) &&        schematype.schema.discriminators != null) {      const key = get(schematype, 'schema.options.discriminatorKey');      const discriminatorValuePath = subpath + '.' + key;      const discriminatorFilterPath =        discriminatorValuePath.replace(/\.\d+\./, '.');      let discriminatorKey = null;
      if (discriminatorValuePath in filter) {        discriminatorKey = filter[discriminatorValuePath];      }      if (discriminatorFilterPath in filter) {        discriminatorKey = filter[discriminatorFilterPath];      }
      const wrapperPath = subpath.replace(/\.\d+$/, '');      if (schematype.$isMongooseDocumentArrayElement &&          get(filter[wrapperPath], '$elemMatch.' + key) != null) {        discriminatorKey = filter[wrapperPath].$elemMatch[key];      }
      if (discriminatorValuePath in update) {        discriminatorKey = update[discriminatorValuePath];      }
      for (const filterKey of Object.keys(updatedPathsByFilter)) {        const schemaKey = updatedPathsByFilter[filterKey] + '.' + key;        const arrayFilterKey = filterKey + '.' + key;        if (schemaKey === discriminatorFilterPath) {          const filter = arrayFilters.find(filter => filter.hasOwnProperty(arrayFilterKey));          if (filter != null) {            discriminatorKey = filter[arrayFilterKey];          }        }      }
      if (discriminatorKey == null) {        continue;      }
      const discriminatorSchema = getDiscriminatorByValue(schematype.caster.discriminators, discriminatorKey).schema;
      const rest = parts.slice(i + 1).join('.');      schematype = discriminatorSchema.path(rest);      if (schematype != null) {        type = discriminatorSchema._getPathType(rest);        break;      }    }  }
  return { type: type, schematype: schematype };};