objection 3.1.5 → 3.3.0

package/lib/queryBuilder/QueryBuilder.js

@@ -43,8 +43,10 @@ const { SelectOperation } = require('./operations/select/SelectOperation');
 const { EagerOperation } = require('./operations/eager/EagerOperation');
 const { RangeOperation } = require('./operations/RangeOperation');
 const { FirstOperation } = require('./operations/FirstOperation');
+const { NoneOperation } = require('./operations/NoneOperation');
 const { FromOperation } = require('./operations/FromOperation');
 const { KnexOperation } = require('./operations/KnexOperation');
+const { wrapWhereGroups } = require('./whereGroups');
 
 class QueryBuilder extends QueryBuilderBase {
   static init(self, modelClass) {
@@ -56,8 +58,13 @@ class QueryBuilder extends QueryBuilderBase {
     self._modifiers = {};
 
     self._allowedGraphExpression = null;
+    self._graphModifiersAtPath = [];
+    // The eager algorithm that was most recently used explicitly, see `withGraph()`.
+    self._graphAlgorithm = null;
+    self._isJoinChildQuery = false;
     self._findOperationOptions = modelClass.defaultFindOptions;
     self._relatedQueryFor = null;
+    self._internalSelections = new Set();
 
     self._findOperationFactory = findOperationFactory;
     self._insertOperationFactory = insertOperationFactory;
@@ -76,6 +83,27 @@ class QueryBuilder extends QueryBuilderBase {
     return RelationExpression.create(expr).toPojo();
   }
 
+  childQueryOf(query, options = {}) {
+    super.childQueryOf(query, options);
+
+    if (query) {
+      this._isJoinChildQuery = !!options.isJoinChildQuery;
+
+      if (query.isObjectionQueryBuilder) {
+        this._graphAlgorithm = query._graphAlgorithm;
+      }
+    }
+
+    return this;
+  }
+
+  // Returns true if this query was created for a relation that is loaded using
+  // `withGraphJoined()`. Such queries are only used to build the join and are
+  // never executed themselves.
+  isJoinChildQuery() {
+    return this._isJoinChildQuery;
+  }
+
   tableNameFor(modelClassOrTableName, newTableName) {
     return super.tableNameFor(getTableName(modelClassOrTableName), newTableName);
   }
@@ -189,20 +217,52 @@ class QueryBuilder extends QueryBuilderBase {
   }
 
   withGraphFetched(exp, options = {}) {
-    return this._withGraph(exp, options, getWhereInEagerAlgorithm(this));
+    return this._withGraphUsing(exp, options, getWhereInEagerAlgorithm(this));
   }
 
   withGraphJoined(exp, options = {}) {
-    return this._withGraph(exp, options, getJoinEagerAlgorithm(this));
+    return this._withGraphUsing(exp, options, getJoinEagerAlgorithm(this));
+  }
+
+  // Like `withGraphFetched()` or `withGraphJoined()` with `options.algorithm`
+  // set to 'fetch' or 'join'. Without it, the top-level relations that are
+  // already loaded by one of the algorithms are merged into it, and new ones
+  // use the most recently used algorithm.
+  withGraph(exp, { algorithm, ...options } = {}) {
+    if (algorithm !== undefined) {
+      return this._withGraphUsing(exp, options, getEagerAlgorithmByName(this, algorithm));
+    }
+
+    const parsedExp = parseRelationExpression(this.modelClass(), exp);
+
+    for (const [algorithm, groupExp] of groupByEagerAlgorithm(this, parsedExp)) {
+      this._withGraph(groupExp, options, algorithm);
+    }
+
+    return this;
+  }
+
+  _withGraphUsing(exp, options, algorithm) {
+    this._graphAlgorithm = algorithm;
+    return this._withGraph(exp, options, algorithm);
   }
 
   _withGraph(exp, options, algorithm) {
     const eagerOp = ensureEagerOperation(this, algorithm);
     const parsedExp = parseRelationExpression(this.modelClass(), exp);
 
+    // The `joinOperation` option only applies to the relations of this call,
+    // see `RelationJoiner`. All other options are shared by all calls.
+    const { joinOperation, ...graphOptions } = options;
+
     eagerOp.expression = eagerOp.expression.merge(parsedExp);
-    eagerOp.graphOptions = { ...eagerOp.graphOptions, ...options };
+    eagerOp.graphOptions = { ...eagerOp.graphOptions, ...graphOptions };
 
+    if (joinOperation) {
+      eagerOp.joinOperations.push({ expression: parsedExp, joinOperation });
+    }
+
+    checkMixedEager(this);
     checkEager(this);
     return this;
   }
@@ -223,28 +283,30 @@ class QueryBuilder extends QueryBuilderBase {
   }
 
   graphExpressionObject() {
-    const eagerOp = this.findOperation(EagerOperation);
+    const expression = getGraphExpression(this);
 
-    if (eagerOp && !eagerOp.expression.isEmpty) {
-      return eagerOp.expression.toPojo();
+    if (expression && !expression.isEmpty) {
+      return expression.toPojo();
     } else {
       return null;
     }
   }
 
   graphModifiersAtPath() {
-    const eagerOp = this.findOperation(EagerOperation);
+    const expression = getGraphExpression(this);
 
-    if (eagerOp && !eagerOp.expression.isEmpty) {
-      return eagerOp.modifiersAtPath.map((it) => Object.assign({}, it));
+    if (expression && !expression.isEmpty) {
+      return this._graphModifiersAtPath.map((it) => Object.assign({}, it));
     } else {
       return [];
     }
   }
 
   modifyGraph(path, modifier) {
-    const eagerOp = ensureEagerOperation(this);
-    eagerOp.modifiersAtPath.push({ path, modifier });
+    // The modifiers are shared by all eager operations. They only take effect
+    // for the paths that exist in each operation's expression.
+    ensureEagerOperation(this);
+    this._graphModifiersAtPath.push({ path, modifier });
     return this;
   }
 
@@ -301,8 +363,7 @@ class QueryBuilder extends QueryBuilderBase {
   }
 
   hasWithGraph() {
-    const eagerOp = this.findOperation(EagerOperation);
-    return !!eagerOp && !eagerOp.expression.isEmpty;
+    return findEagerOperations(this).some((eagerOp) => !eagerOp.expression.isEmpty);
   }
 
   isSelectAll() {
@@ -350,6 +411,9 @@ class QueryBuilder extends QueryBuilderBase {
     builder._modifiers = { ...this._modifiers };
 
     builder._allowedGraphExpression = this._allowedGraphExpression;
+    builder._graphModifiersAtPath = this._graphModifiersAtPath.slice();
+    builder._graphAlgorithm = this._graphAlgorithm;
+    builder._isJoinChildQuery = this._isJoinChildQuery;
     builder._findOperationOptions = this._findOperationOptions;
     builder._relatedQueryFor = this._relatedQueryFor;
 
@@ -371,8 +435,17 @@ class QueryBuilder extends QueryBuilderBase {
     return builder;
   }
 
+  // Registers a property of the result models that was selected internally,
+  // e.g. by an eager operation, without the user asking for it. Such properties
+  // are omitted from the result models before `runAfter` hooks are called.
+  addInternalSelection(prop) {
+    this._internalSelections.add(prop);
+    return this;
+  }
+
   clearWithGraph() {
     this.clear(EagerOperation);
+    this._graphAlgorithm = null;
     return this;
   }
 
@@ -419,9 +492,27 @@ class QueryBuilder extends QueryBuilderBase {
   async resultSize() {
     const knex = this.knex();
     const builder = this.clone().clear(/orderBy|offset|limit/);
+    const joinEagerOp = builder.findOperation(JoinEagerOperation);
+
+    if (joinEagerOp) {
+      // `withGraphJoined` needs the table metadata to build its selects.
+      await joinEagerOp.onBefore3(builder);
+    }
 
     const countQuery = knex.count('* as count').from((knexBuilder) => {
-      builder.toKnexQuery(knexBuilder).as('temp');
+      // Also clear the order on the built knex query, since `orderBy` calls
+      // can be added at build time, e.g. by a relation's `modify`.
+      knexBuilder = builder.toKnexQuery(knexBuilder).clearOrder();
+
+      if (joinEagerOp) {
+        // The joins of `withGraphJoined` return one row per joined child.
+        // Count the distinct root models instead.
+        const tableRef = builder.tableRef();
+        const idColumns = builder.modelClass().getIdColumnArray();
+        knexBuilder.clearSelect().distinct(idColumns.map((col) => `${tableRef}.${col}`));
+      }
+
+      knexBuilder.as('temp');
     });
 
     if (this.internalOptions().debug) {
@@ -808,6 +899,10 @@ class QueryBuilder extends QueryBuilderBase {
     return this.addOperation(new FirstOperation('first'), args);
   }
 
+  none() {
+    return this.addOperation(new NoneOperation('none'), []);
+  }
+
   joinRelated(expression, options) {
     ensureJoinRelatedOperation(this, 'innerJoin').addCall({
       expression,
@@ -880,6 +975,26 @@ class QueryBuilder extends QueryBuilderBase {
     return this;
   }
 
+  updateById(id, modelOrObject) {
+    return this.findById(id)
+      .update(modelOrObject)
+      .runBefore((_, builder) => {
+        if (!builder.internalOptions().skipUndefined) {
+          assertIdNotUndefined(id, `undefined was passed to updateById`);
+        }
+      });
+  }
+
+  patchById(id, modelOrObject) {
+    return this.findById(id)
+      .patch(modelOrObject)
+      .runBefore((_, builder) => {
+        if (!builder.internalOptions().skipUndefined) {
+          assertIdNotUndefined(id, `undefined was passed to patchById`);
+        }
+      });
+  }
+
   deleteById(id) {
     return this.findById(id)
       .delete()
@@ -922,6 +1037,10 @@ class QueryBuilder extends QueryBuilderBase {
     return this.addOperation(new FromOperation('from'), args);
   }
 
+  updateFrom(...args) {
+    return this.addOperation(new KnexOperation('updateFrom'), args);
+  }
+
   table(...args) {
     return this.addOperation(new FromOperation('table'), args);
   }
@@ -930,6 +1049,15 @@ class QueryBuilder extends QueryBuilderBase {
     if (arguments.length === 0) {
       return this._relatedQueryFor;
     } else {
+      // The write operation factories installed by the static `relatedQuery()`
+      // read `for()` when the write method is called. Setting it afterwards
+      // would make the query silently target the wrong rows.
+      if (this._findOperationFactory !== findOperationFactory && !this.isFind()) {
+        throw new Error(
+          'for() must be called before insert, update, patch, delete, relate or unrelate on queries created using the static relatedQuery method',
+        );
+      }
+
       this._relatedQueryFor = relatedQueryFor;
       return this;
     }
@@ -952,48 +1080,143 @@ function getTableName(modelClassOrTableName) {
   }
 }
 
+// A query builder can hold at most one eager operation of each kind: one
+// `JoinEagerOperation` for `withGraphJoined` and one `WhereInEagerOperation`
+// (or its subclass `NaiveEagerOperation`) for `withGraphFetched`.
 function ensureEagerOperation(builder, algorithm = null) {
   const modelClass = builder.modelClass();
   const defaultGraphOptions = modelClass.getDefaultGraphOptions();
-  const eagerOp = builder.findOperation(EagerOperation);
 
-  if (algorithm) {
-    const EagerOperationClass = getOperationClassForEagerAlgorithm(builder, algorithm);
+  if (!algorithm) {
+    const eagerOp = builder.findOperation(EagerOperation);
 
-    if (eagerOp instanceof EagerOperationClass) {
+    if (eagerOp) {
       return eagerOp;
-    } else {
-      const newEagerOp = new EagerOperationClass('eager', {
-        defaultGraphOptions,
-      });
+    }
 
-      if (eagerOp) {
-        newEagerOp.cloneFrom(eagerOp);
-      }
+    algorithm = getWhereInEagerAlgorithm(builder);
+  }
 
-      builder.clear(EagerOperation);
-      builder.addOperation(newEagerOp);
+  const EagerOperationClass = getOperationClassForEagerAlgorithm(builder, algorithm);
+  const EagerOperationKind = getEagerOperationKind(EagerOperationClass);
+  const eagerOp = builder.findOperation(EagerOperationKind);
 
-      return newEagerOp;
-    }
+  if (eagerOp && eagerOp.constructor === EagerOperationClass) {
+    return eagerOp;
+  }
+
+  const newEagerOp = new EagerOperationClass('eager', {
+    defaultGraphOptions,
+  });
+
+  if (eagerOp) {
+    // Switching between algorithms of the same kind, e.g. from
+    // `WhereInEagerOperation` to `NaiveEagerOperation`.
+    newEagerOp.cloneFrom(eagerOp);
+    builder.clear(EagerOperationKind);
+  } else if (!builder.has(EagerOperation)) {
+    // The `modifyGraph` modifiers only live as long as an eager operation.
+    builder._graphModifiersAtPath = [];
+  }
+
+  builder.addOperation(newEagerOp);
+
+  // Keep the joined operation before the fetched one (see `findEagerOperations`),
+  // even if it is added after `addImplicitOperations`, e.g. in `runBefore`.
+  const fetchOp =
+    EagerOperationKind === JoinEagerOperation && builder.findOperation(WhereInEagerOperation);
+
+  if (fetchOp) {
+    builder.removeOperation(fetchOp).addOperation(fetchOp);
+  }
+
+  return newEagerOp;
+}
+
+function getEagerOperationKind(EagerOperationClass) {
+  return EagerOperationClass === JoinEagerOperation ? JoinEagerOperation : WhereInEagerOperation;
+}
+
+function findEagerOperations(builder) {
+  // Joined operations first, so that their `onBuild` runs before the fetched
+  // one's. See `WhereInEagerOperation.onBuild`.
+  return [
+    builder.findOperation(JoinEagerOperation),
+    builder.findOperation(WhereInEagerOperation),
+  ].filter(Boolean);
+}
+
+function getGraphExpression(builder) {
+  const eagerOps = findEagerOperations(builder);
+
+  if (eagerOps.length === 0) {
+    return null;
+  }
+
+  return eagerOps.reduce(
+    (expression, eagerOp) => expression.merge(eagerOp.expression),
+    RelationExpression.create(),
+  );
+}
+
+function getEagerAlgorithmByName(builder, name) {
+  if (name === 'fetch') {
+    return getWhereInEagerAlgorithm(builder);
+  } else if (name === 'join') {
+    return getJoinEagerAlgorithm(builder);
   } else {
-    if (eagerOp) {
-      return eagerOp;
-    } else {
-      const EagerOperationClass = getOperationClassForEagerAlgorithm(
-        builder,
-        getWhereInEagerAlgorithm(builder),
-      );
+    throw new Error(`unknown graph algorithm "${name}", expected "fetch" or "join"`);
+  }
+}
 
-      const newEagerOp = new EagerOperationClass('eager', {
-        defaultGraphOptions,
-      });
+function getEagerAlgorithmOfOperation(builder, eagerOp) {
+  if (eagerOp instanceof JoinEagerOperation) {
+    return getJoinEagerAlgorithm(builder);
+  } else if (eagerOp instanceof NaiveEagerOperation) {
+    return getNaiveEagerAlgorithm(builder);
+  } else {
+    return getWhereInEagerAlgorithm(builder);
+  }
+}
 
-      builder.addOperation(newEagerOp);
+// Splits `expression` by its top-level relations into one expression per eager
+// algorithm. Relations that are already loaded by one of the eager operations
+// keep its algorithm, new ones use the most recently used one.
+function groupByEagerAlgorithm(builder, expression) {
+  const defaultAlgorithm = builder._graphAlgorithm || getWhereInEagerAlgorithm(builder);
+  const { node } = expression;
+  const rootProps = {};
+  const groups = new Map();
+
+  for (const key of Object.keys(node)) {
+    if (key.startsWith('$')) {
+      rootProps[key] = node[key];
+    }
+  }
 
-      return newEagerOp;
+  for (const childName of node.$childNames) {
+    const eagerOp = findEagerOperations(builder).find(
+      (op) => op.expression.node.$allRecursive || op.expression.node[childName],
+    );
+
+    const algorithm = eagerOp ? getEagerAlgorithmOfOperation(builder, eagerOp) : defaultAlgorithm;
+    let group = groups.get(algorithm);
+
+    if (!group) {
+      group = { ...rootProps, $childNames: [] };
+      groups.set(algorithm, group);
     }
+
+    group.$childNames.push(childName);
+    group[childName] = node[childName];
   }
+
+  if (groups.size === 0) {
+    // No top-level relations, e.g. `*` or an empty expression.
+    return [[defaultAlgorithm, expression]];
+  }
+
+  return [...groups].map(([algorithm, group]) => [algorithm, RelationExpression.create(group)]);
 }
 
 function getWhereInEagerAlgorithm(builder) {
@@ -1036,14 +1259,44 @@ function parseRelationExpression(modelClass, exp) {
   }
 }
 
+function checkMixedEager(builder) {
+  const joinOp = builder.findOperation(JoinEagerOperation);
+  const fetchOp = builder.findOperation(WhereInEagerOperation);
+
+  if (!joinOp || !fetchOp) {
+    return;
+  }
+
+  const joinNode = joinOp.expression.node;
+  const fetchNode = fetchOp.expression.node;
+  const isUsed = (node) => node.$allRecursive || node.$childNames.length > 0;
+
+  if (!isUsed(joinNode) || !isUsed(fetchNode)) {
+    return;
+  }
+
+  if (joinNode.$allRecursive || fetchNode.$allRecursive) {
+    throw new Error(
+      'relation expression `*` cannot be used when mixing withGraphJoined and withGraphFetched',
+    );
+  }
+
+  for (const childName of joinNode.$childNames) {
+    if (fetchNode.$childNames.includes(childName)) {
+      throw new Error(
+        `relation \`${childName}\` cannot be loaded with both withGraphJoined and withGraphFetched`,
+      );
+    }
+  }
+}
+
 function checkEager(builder) {
-  const eagerOp = builder.findOperation(EagerOperation);
+  const expr = getGraphExpression(builder);
 
-  if (!eagerOp) {
+  if (!expr) {
     return;
   }
 
-  const expr = eagerOp.expression;
   const allowedExpr = builder.allowedGraphExpression();
 
   if (expr.numChildren > 0 && allowedExpr && !allowedExpr.isSubExpression(expr)) {
@@ -1065,6 +1318,7 @@ function findQueryExecutorOperation(builder) {
 function beforeExecute(builder) {
   let promise = Promise.resolve();
 
+  checkRelatedQueryFor(builder);
   builder = addImplicitOperations(builder);
 
   // Resolve all before hooks before building and executing the query
@@ -1110,6 +1364,7 @@ function afterExecute(builder, result) {
 
   promise = chainOperationHooks(promise, builder, 'onAfter1');
   promise = chainOperationHooks(promise, builder, 'onAfter2');
+  promise = promise.then((result) => omitInternalSelections(builder, result));
 
   promise = chainHooks(promise, builder, builder.context().runAfter);
   promise = chainHooks(promise, builder, builder.internalContext().runAfter);
@@ -1119,6 +1374,22 @@ function afterExecute(builder, result) {
   return promise;
 }
 
+function omitInternalSelections(builder, result) {
+  const props = builder._internalSelections;
+
+  if (props.size && Array.isArray(result) && isObject(result[0])) {
+    const modelClass = builder.resultModelClass();
+
+    for (const model of result) {
+      for (const prop of props) {
+        modelClass.omitImpl(model, prop);
+      }
+    }
+  }
+
+  return result;
+}
+
 class ReturnImmediatelyException {
   constructor(value) {
     this.value = value;
@@ -1181,6 +1452,7 @@ function ensureJoinRelatedOperation(builder, joinOperation) {
 }
 
 function prebuildQuery(builder) {
+  checkRelatedQueryFor(builder);
   builder = addImplicitOperations(builder);
   builder = callOnBuildHooks(builder);
 
@@ -1193,6 +1465,17 @@ function prebuildQuery(builder) {
   }
 }
 
+function checkRelatedQueryFor(builder) {
+  // `for()` is only consumed by the operation factories installed by the static
+  // `relatedQuery()`. The default ones ignore it, which would silently make the
+  // query target all rows of the table.
+  if (builder.for() !== null && builder._findOperationFactory === findOperationFactory) {
+    throw new Error(
+      'for() can only be used with queries created using the static relatedQuery method',
+    );
+  }
+}
+
 function addImplicitOperations(builder) {
   if (builder.isFind()) {
     // If no write operations have been called at this point this query is a
@@ -1215,10 +1498,13 @@ function addFindOperation(builder) {
 }
 
 function moveEagerOperationToEnd(builder) {
-  const eagerOp = builder.findOperation(EagerOperation);
+  const eagerOps = findEagerOperations(builder);
 
   builder.clear(EagerOperation);
-  builder.addOperation(eagerOp);
+
+  for (const eagerOp of eagerOps) {
+    builder.addOperation(eagerOp);
+  }
 }
 
 function callOnBuildHooks(builder) {
@@ -1226,7 +1512,7 @@ function callOnBuildHooks(builder) {
   callOnBuildFuncs(builder, builder.internalContext().onBuild);
 
   builder.executeOnBuild();
-  return builder;
+  return wrapWhereGroups(builder);
 }
 
 function callOnBuildFuncs(builder, func) {
@@ -1240,6 +1526,12 @@ function callOnBuildFuncs(builder, func) {
 function buildKnexQuery(builder, knexBuilder = builder.knex().queryBuilder()) {
   knexBuilder = builder.executeOnBuildKnex(knexBuilder);
 
+  const noneOperation = builder.findOperation(NoneOperation);
+
+  if (noneOperation) {
+    knexBuilder = noneOperation.onAfterBuildKnex(knexBuilder);
+  }
+
   const fromOperation = builder.findLastOperation(QueryBuilderBase.FromSelector);
 
   if (!builder.isPartial()) {

package/lib/queryBuilder/QueryBuilderOperationSupport.js

@@ -26,6 +26,7 @@ class QueryBuilderOperationSupport {
     self._parentQuery = null;
     self._isPartialQuery = false;
     self._activeOperations = [];
+    self._whereGroup = null;
   }
 
   static forClass(modelClass) {
@@ -413,6 +414,10 @@ class QueryBuilderOperationSupport {
     const shouldAdd = this.callOperationMethod(operation, 'onAdd', [this, args]);
 
     if (shouldAdd) {
+      if (this._whereGroup) {
+        operation.whereGroup = this._whereGroup;
+      }
+
       if (this._activeOperations.length) {
         const { operation: parentOperation, hookName } = last(this._activeOperations);
         parentOperation.addChildOperation(hookName, operation);

package/lib/queryBuilder/ReferenceBuilder.js

@@ -1,6 +1,9 @@
 'use strict';
 
-const { parseFieldExpression } = require('../utils/parseFieldExpression');
+const {
+  parseFieldExpression,
+  toPostgresJsonPathLiteral,
+} = require('../utils/parseFieldExpression');
 const { isObject } = require('../utils/objectUtils');
 
 class ReferenceBuilder {
@@ -185,8 +188,7 @@ class ReferenceBuilder {
 
     if (this._parsedExpr.access.length > 0) {
       const extractor = this._cast ? '#>>' : '#>';
-      const jsonFieldRef = this._parsedExpr.access.map((field) => field.ref).join(',');
-      return `??${extractor}'{${jsonFieldRef}}'`;
+      return `??${extractor}${toPostgresJsonPathLiteral(this._parsedExpr.access)}`;
     } else {
       return '??';
     }

package/lib/queryBuilder/RelationExpression.js

@@ -229,6 +229,14 @@ function toString(node) {
   let childExpr = childNames.map((childName) => node[childName]).map(toString);
   let str = node.$relation;
 
+  if (node.$modify.length) {
+    str += `(${node.$modify.join(', ')})`;
+  }
+
+  if (node.$name !== node.$relation) {
+    str += ` as ${node.$name}`;
+  }
+
   if (node.$recursive) {
     if (isNumber(node.$recursive)) {
       str += '.^' + node.$recursive;
@@ -245,14 +253,6 @@ function toString(node) {
     childExpr = childExpr[0];
   }
 
-  if (node.$modify.length) {
-    str += `(${node.$modify.join(', ')})`;
-  }
-
-  if (node.$name !== node.$relation) {
-    str += ` as ${node.$name}`;
-  }
-
   if (childExpr) {
     if (str) {
       return `${str}.${childExpr}`;
@@ -355,7 +355,19 @@ function normalizeAllRecursive(node, allRecusive) {
 }
 
 function normalizeChildNames(node) {
-  return (node && node.$childNames && node.$childNames.slice()) || getChildNames(node);
+  const childNames = getChildNames(node);
+
+  if (node && node.$childNames) {
+    // The actual keys of the node are authoritative, since the node may be a
+    // modified copy of `graphExpressionObject()` with a stale `$childNames`.
+    // Keep the order of `$childNames` for the children that still exist.
+    return union(
+      node.$childNames.filter((childName) => childNames.includes(childName)),
+      childNames,
+    );
+  } else {
+    return childNames;
+  }
 }
 
 function findExpressionsAtPath(target, path, results) {