objection 3.1.4 → 3.2.0

package/lib/queryBuilder/graph/GraphOptions.js

@@ -51,6 +51,10 @@ class GraphOptions {
 
   // Like `shouldRelate` but ignores settings that explicitly disable relate operations.
   shouldRelateIgnoreDisable(node, graphData) {
+    if (node.toBeUnrelated || node.toBeDeleted) {
+      return false;
+    }
+
     if (node.isReference || node.isDbReference) {
       return true;
     }
@@ -71,6 +75,10 @@ class GraphOptions {
 
   // Like `shouldInsert` but ignores settings that explicitly disable insert operations.
   shouldInsertIgnoreDisable(node, graphData) {
+    if (node.toBeUnrelated || node.toBeDeleted) {
+      return false;
+    }
+
     return (
       !getCurrentNode(node, graphData) &&
       !this.shouldRelateIgnoreDisable(node, graphData) &&
@@ -89,6 +97,10 @@ class GraphOptions {
   // Like `shouldPatch() || shouldUpdate()` but ignores settings that explicitly disable
   // update or patch operations.
   shouldPatchOrUpdateIgnoreDisable(node, graphData) {
+    if (node.toBeUnrelated || node.toBeDeleted) {
+      return false;
+    }
+
     if (this.shouldRelate(node, graphData)) {
       // We should update all nodes that are going to be related. Note that
       // we don't actually update anything unless there is something to update
@@ -121,16 +133,23 @@ class GraphOptions {
   }
 
   shouldUnrelate(currentNode, graphData) {
+    const node = getNode(currentNode, graphData.graph);
+    if (node && node.toBeUnrelated) return true;
+
     return (
-      !getNode(currentNode, graphData.graph) &&
+      !node &&
       !this._hasOption(currentNode, NO_UNRELATE) &&
       this.shouldUnrelateIgnoreDisable(currentNode)
     );
   }
 
   shouldDelete(currentNode, graphData) {
+    const node = getNode(currentNode, graphData.graph);
+    // `#unrelate` takes precedence over `#delete` if both are set.
+    if (node && node.toBeDeleted && !node.toBeUnrelated) return true;
+
     return (
-      !getNode(currentNode, graphData.graph) &&
+      !node &&
       !this._hasOption(currentNode, NO_DELETE) &&
       !this.shouldUnrelateIgnoreDisable(currentNode)
     );

package/lib/queryBuilder/graph/GraphUpsert.js

@@ -91,6 +91,7 @@ function pruneGraphs() {
 
     if (!graphData.graphOptions.isInsertOnly()) {
       pruneDeletedBranches(graphData);
+      pruneUnrelatedOrDeletedBranches(graphData);
     }
 
     return graphData;
@@ -136,6 +137,19 @@ function pruneDeletedBranches(graphData) {
   removeNodesFromGraph(new Set(rootsNotInRelation), currentGraph);
 }
 
+// Models marked with `#unrelate` or `#delete` are unrelated or deleted
+// as a whole. Their relations are ignored, both in the upserted graph
+// and in the current graph.
+function pruneUnrelatedOrDeletedBranches(graphData) {
+  const { graph, currentGraph } = graphData;
+
+  const roots = findRoots(graph.nodes.filter((node) => node.toBeUnrelatedOrDeleted));
+  const currentRoots = roots.map((node) => currentGraph.nodeForNode(node)).filter(Boolean);
+
+  removeBranchesFromGraph(roots, graph);
+  removeBranchesFromGraph(currentRoots, currentGraph);
+}
+
 function findRoots(nodes) {
   const nodeSet = new Set(nodes);
 
@@ -192,6 +206,7 @@ function checkForErrors(builder) {
     checkForNotFoundErrors(graphData, builder);
     checkForUnallowedRelationErrors(graphData, builder);
     checkForUnallowedReferenceErrors(graphData, builder);
+    checkForRootUnrelateOrDeleteErrors(graphData, builder);
 
     if (graphData.graphOptions.isInsertOnly()) {
       checkForHasManyRelateErrors(graphData);
@@ -207,6 +222,8 @@ function checkForNotFoundErrors(graphData, builder) {
   for (const node of graph.nodes) {
     if (
       node.obj.$hasId() &&
+      !node.toBeUnrelated &&
+      !node.toBeDeleted &&
       !graphOptions.shouldInsertIgnoreDisable(node, graphData) &&
       !graphOptions.shouldRelateIgnoreDisable(node, graphData) &&
       !currentGraph.nodeForNode(node)
@@ -259,6 +276,19 @@ function checkForUnallowedReferenceErrors(graphData, builder) {
   }
 }
 
+function checkForRootUnrelateOrDeleteErrors(graphData, builder) {
+  for (const node of graphData.graph.nodes) {
+    if (!node.parentEdge && node.toBeUnrelatedOrDeleted) {
+      const { graphUnrelateProp, graphDeleteProp } = node.modelClass;
+
+      throw builder.modelClass().createValidationError({
+        type: ValidationErrorType.InvalidGraph,
+        message: `${graphUnrelateProp} and ${graphDeleteProp} can only be used for related models, not for root models`,
+      });
+    }
+  }
+}
+
 function checkForHasManyRelateErrors(graphData) {
   const { graph, graphOptions } = graphData;
 

package/lib/queryBuilder/graph/delete/GraphDeleteAction.js

@@ -40,20 +40,26 @@ class GraphDeleteAction extends GraphAction {
       const nodesByParent = groupBy(nodes, getParent);
 
       nodesByParent.forEach((nodes, parentNode) => {
-        const shouldUnrelate = this.graphOptions.shouldUnrelate(nodes[0], this.graphData);
-
-        const builder = parentNode.obj.$relatedQuery(relation.name).childQueryOf(parentBuilder);
-
-        if (!relation.isObjectionBelongsToOneRelation) {
-          // This is useless in case of BelongsToOneRelation.
-          builder.findByIds(nodes.map((node) => node.obj.$id()));
-        }
-
-        for (const node of nodes) {
-          node.userData.deleted = true;
-        }
-
-        builders.push(shouldUnrelate ? builder.unrelate() : builder.delete());
+        // Nodes of the same relation and parent can still require different
+        // operations when they are marked with `#unrelate` or `#delete`.
+        const nodesByShouldUnrelate = groupBy(nodes, (node) =>
+          this.graphOptions.shouldUnrelate(node, this.graphData),
+        );
+
+        nodesByShouldUnrelate.forEach((nodes, shouldUnrelate) => {
+          const builder = parentNode.obj.$relatedQuery(relation.name).childQueryOf(parentBuilder);
+
+          if (!relation.isObjectionBelongsToOneRelation) {
+            // This is useless in case of BelongsToOneRelation.
+            builder.findByIds(nodes.map((node) => node.obj.$id()));
+          }
+
+          for (const node of nodes) {
+            node.userData.deleted = true;
+          }
+
+          builders.push(shouldUnrelate ? builder.unrelate() : builder.delete());
+        });
       });
     });
 

package/lib/queryBuilder/graph/insert/GraphInsert.js

@@ -30,6 +30,12 @@ class GraphInsert extends GraphOperation {
   }
 
   _createRelationDependency(edge, dependencies) {
+    if (edge.relatedNode.toBeUnrelatedOrDeleted) {
+      // Models marked with `#unrelate` or `#delete` are never inserted or
+      // related, so their keys must not be copied to the owner (or vice versa).
+      return;
+    }
+
     if (edge.relation.isObjectionHasManyRelation) {
       // In case of HasManyRelation the related node depends on the owner node
       // because the related node has the foreign key.

package/lib/queryBuilder/graph/insert/GraphInsertAction.js

@@ -174,6 +174,8 @@ class GraphInsertAction extends GraphAction {
 
     for (const node of nodes) {
       delete node.obj[modelClass.uidProp];
+      delete node.obj[modelClass.graphUnrelateProp];
+      delete node.obj[modelClass.graphDeleteProp];
       node.obj.$validate(null, { dataPath: node.dataPathKey });
     }
 

package/lib/queryBuilder/graph/patch/GraphPatchAction.js

@@ -75,6 +75,8 @@ class GraphPatchAction extends GraphAction {
     delete node.obj[node.modelClass.uidProp];
     delete node.obj[node.modelClass.uidRefProp];
     delete node.obj[node.modelClass.dbRefProp];
+    delete node.obj[node.modelClass.graphUnrelateProp];
+    delete node.obj[node.modelClass.graphDeleteProp];
 
     node.obj.$validate(null, {
       dataPath: node.dataPathKey,
@@ -122,7 +124,9 @@ class GraphPatchAction extends GraphAction {
         edge.isOwnerNode(node) &&
         edge.relation &&
         edge.relation.isObjectionBelongsToOneRelation &&
-        edge.relation.relatedProp.hasProps(edge.relatedNode.obj)
+        edge.relation.relatedProp.hasProps(edge.relatedNode.obj) &&
+        // Models marked with `#unrelate` or `#delete` are handled below.
+        !edge.relatedNode.toBeUnrelatedOrDeleted
       ) {
         const { relation } = edge;
 
@@ -153,7 +157,8 @@ class GraphPatchAction extends GraphAction {
       if (
         edge.isOwnerNode(currentNode) &&
         edge.relation.isObjectionBelongsToOneRelation &&
-        node.obj[edge.relation.name] === null &&
+        (node.obj[edge.relation.name] === null ||
+          isToBeUnrelatedOrDeleted(this.graph.nodeForNode(edge.relatedNode))) &&
         this.graphOptions.shouldDeleteOrUnrelate(edge.relatedNode, this.graphData)
       ) {
         const { relation } = edge;
@@ -231,7 +236,10 @@ class GraphPatchAction extends GraphAction {
   }
 
   _createRootBuilder(node) {
-    return node.obj.$query();
+    const currentNode = this.currentGraph.nodeForNode(node);
+    const currentObj = currentNode && currentNode.obj;
+
+    return currentObj ? currentObj.$query() : node.obj.$query();
   }
 }
 
@@ -250,6 +258,10 @@ function nonStrictEquals(val1, val2) {
   return jsonEquals(val1, val2);
 }
 
+function isToBeUnrelatedOrDeleted(node) {
+  return !!node && node.toBeUnrelatedOrDeleted;
+}
+
 module.exports = {
   GraphPatchAction,
 };

package/lib/queryBuilder/join/RelationJoiner.js

@@ -81,6 +81,23 @@ class RelationJoiner {
     }
   }
 
+  releaseInternalRootSelection(column) {
+    const rootTableNode = this.tableTree && this.tableTree.rootNode;
+
+    if (!rootTableNode || !this.internalSelections) {
+      return false;
+    }
+
+    const alias = rootTableNode.getColumnAliasForColumn(column);
+    const count = this.internalSelections.length;
+
+    this.internalSelections = this.internalSelections.filter(
+      (it) => it.table !== rootTableNode.alias || it.alias !== alias,
+    );
+
+    return this.internalSelections.length !== count;
+  }
+
   parseResult(builder, flatRows) {
     const parser = JoinResultParser.create({
       tableTree: this._getTableTree(builder),

package/lib/queryBuilder/operations/DelegateOperation.js

@@ -11,6 +11,10 @@ class DelegateOperation extends QueryBuilderOperation {
     this.delegate = opt.delegate;
   }
 
+  get modelOptions() {
+    return this.delegate.modelOptions;
+  }
+
   is(OperationClass) {
     return super.is(OperationClass) || this.delegate.is(OperationClass);
   }

package/lib/queryBuilder/operations/NoneOperation.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+
+const AggregateSelector =
+  /^(count|countDistinct|min|max|sum|sumDistinct|avg|avgDistinct|groupBy\w*)$/;
+
+class NoneOperation extends QueryBuilderOperation {
+  onBefore1(builder, result) {
+    // Resolve the query without executing it, like `cancelQuery()` does.
+    if (builder.isFind()) {
+      // Aggregate queries are executed to get the result the database
+      // returns for no rows, e.g. `[{ count: 0 }]`.
+      if (!builder.has(AggregateSelector)) {
+        builder.resolve([]);
+      }
+    } else if (builder.isUpdate() || builder.isDelete()) {
+      builder.resolve(builder.has(/returning/) ? [] : 0);
+    } else {
+      throw new Error('none() can only be used with find, update and delete queries');
+    }
+
+    return result;
+  }
+
+  // Called by `buildKnexQuery()` after all other operations have been
+  // built, so that the query matches no rows when it does get executed,
+  // for example as a subquery or in `resultSize()`. The existing where
+  // clauses are removed so that `orWhere()` calls can't match any rows.
+  onAfterBuildKnex(knexBuilder) {
+    return knexBuilder.clearWhere().where(false);
+  }
+}
+
+module.exports = {
+  NoneOperation,
+};

package/lib/queryBuilder/operations/ObjectionToKnexConvertingOperation.js

@@ -106,6 +106,11 @@ function convertArray(arr, builder, i, opName, skipUndefined) {
           `undefined passed as an item in argument #${i} for '${opName}' operation. Call skipUndefined() method to ignore the undefined values.`,
         );
       }
+    } else if (opName === 'orderBy' && isObject(item)) {
+      // knex's `orderBy()` only reads `{ column, order, nulls }` objects from arrays,
+      // so wrap refs, raws and query builders in one and convert its properties.
+      const obj = isPlainObject(item) ? item : { column: item };
+      return convertPlainObject(obj, builder, i, opName, skipUndefined);
     } else if (hasToKnexRawMethod(item)) {
       return convertToKnexRaw(item, builder);
     } else if (isObjectionQueryBuilderBase(item)) {

package/lib/queryBuilder/operations/UpdateAndFetchOperation.js

@@ -14,6 +14,7 @@ class UpdateAndFetchOperation extends DelegateOperation {
 
     this.id = null;
     this.skipIdWhere = false;
+    this.selectOperations = null;
   }
 
   get model() {
@@ -25,6 +26,19 @@ class UpdateAndFetchOperation extends DelegateOperation {
     return this.delegate.onAdd(builder, args.slice(1));
   }
 
+  onBefore3(builder, result) {
+    // Selects have no effect on the update query, so remember them here to
+    // apply them to the fetch query. Collect them before the query is built,
+    // so that selects added by `onBuild` hooks in the shared context aren't
+    // copied, as those hooks run again for the fetch query.
+    this.selectOperations = new Set();
+    builder.forEachOperation(builder.constructor.SelectSelector, (op) => {
+      this.selectOperations.add(op);
+    });
+
+    return super.onBefore3(builder, result);
+  }
+
   onBuild(builder) {
     if (!this.skipIdWhere) {
       builder.findById(this.id);
@@ -43,6 +57,7 @@ class UpdateAndFetchOperation extends DelegateOperation {
     const fetched = await builder
       .emptyInstance()
       .childQueryOf(builder)
+      .copyFrom(builder, (op) => !!this.selectOperations?.has(op))
       .modify((builder) => {
         if (!this.skipIdWhere) {
           builder.findById(this.id);
@@ -52,6 +67,11 @@ class UpdateAndFetchOperation extends DelegateOperation {
 
     if (fetched) {
       this.model.$set(fetched);
+      // A custom `select` may not include the id. The row was fetched by
+      // id, so make sure the result still has it.
+      if (!this.model.$hasId()) {
+        this.model.$id(this.id);
+      }
     }
 
     await super.onAfter2(builder, numUpdated);

package/lib/queryBuilder/operations/eager/EagerOperation.js

@@ -8,14 +8,13 @@ class EagerOperation extends QueryBuilderOperation {
     super(name, opt);
 
     this.expression = RelationExpression.create();
-    this.modifiersAtPath = [];
     this.graphOptions = this.opt.defaultGraphOptions;
   }
 
-  buildFinalExpression() {
+  buildFinalExpression(builder) {
     const expression = this.expression.clone();
 
-    this.modifiersAtPath.forEach((modifier, i) => {
+    builder.graphModifiersAtPath().forEach((modifier, i) => {
       const modifierName = getModifierName(i);
 
       expression.expressionsAtPath(modifier.path).forEach((expr) => {
@@ -30,7 +29,7 @@ class EagerOperation extends QueryBuilderOperation {
     // `modifiers()` returns a clone so we can modify it.
     const modifiers = builder.modifiers();
 
-    this.modifiersAtPath.forEach((modifier, i) => {
+    builder.graphModifiersAtPath().forEach((modifier, i) => {
       const modifierName = getModifierName(i);
 
       modifiers[modifierName] = modifier.modifier;
@@ -41,7 +40,6 @@ class EagerOperation extends QueryBuilderOperation {
 
   cloneFrom(eagerOp) {
     this.expression = eagerOp.expression.clone();
-    this.modifiersAtPath = eagerOp.modifiersAtPath.slice();
     this.graphOptions = Object.assign({}, eagerOp.graphOptions);
   }
 

package/lib/queryBuilder/operations/eager/JoinEagerOperation.js

@@ -21,7 +21,7 @@ class JoinEagerOperation extends EagerOperation {
 
   onBefore3(builder) {
     return this.joiner
-      .setExpression(this.buildFinalExpression())
+      .setExpression(this.buildFinalExpression(builder))
       .setModifiers(this.buildFinalModifiers(builder))
       .setOptions(this.graphOptions)
       .fetchColumnInfo(builder);
@@ -29,12 +29,18 @@ class JoinEagerOperation extends EagerOperation {
 
   onBuild(builder) {
     this.joiner
-      .setExpression(this.buildFinalExpression())
+      .setExpression(this.buildFinalExpression(builder))
       .setModifiers(this.buildFinalModifiers(builder))
       .setOptions(this.graphOptions)
       .build(builder);
   }
 
+  // Stops the joiner from omitting an internally selected column of the root
+  // table from the result. Returns true if such a selection existed.
+  releaseInternalRootSelection(column) {
+    return !!this.joiner && this.joiner.releaseInternalRootSelection(column);
+  }
+
   onRawResult(builder, rows) {
     return this.joiner.parseResult(builder, rows);
   }

package/lib/queryBuilder/operations/eager/WhereInEagerOperation.js

@@ -3,6 +3,7 @@
 const promiseUtils = require('../../../utils/promiseUtils');
 
 const { EagerOperation } = require('./EagerOperation');
+const { JoinEagerOperation } = require('./JoinEagerOperation');
 const { isMsSql, isOracle, isSqlite } = require('../../../utils/knexUtils');
 const { isObject, asArray, flatten, chunk } = require('../../../utils/objectUtils');
 const { ValidationErrorType } = require('../../../model/ValidationError');
@@ -41,7 +42,7 @@ class WhereInEagerOperation extends EagerOperation {
   onBuild(builder) {
     const relationsToFetch = findRelationsToFetch(
       builder.modelClass(),
-      this.buildFinalExpression(),
+      this.buildFinalExpression(builder),
     );
 
     const { selectionsToAdd, selectedProps } = findRelationPropsToSelect(builder, relationsToFetch);
@@ -237,6 +238,11 @@ function findRelationPropsToSelect(builder, relationsToFetch) {
   const selectionsToAdd = [];
   const selectedProps = [];
 
+  // When mixed with `withGraphJoined`, the join operation may have selected
+  // some of the needed columns internally, in which case it would omit them
+  // from the result models before we get to use them.
+  const joinOp = builder.findOperation(JoinEagerOperation);
+
   // Collect columns that need to be selected for the eager fetch
   // to work that are not currently selected.
   for (const { relation } of relationsToFetch) {
@@ -247,9 +253,15 @@ function findRelationPropsToSelect(builder, relationsToFetch) {
       const prop = ownerProp.props[c];
       const col = ownerProp.cols[c];
 
-      if (!builder.hasSelectionAs(fullCol, col) && selectionsToAdd.indexOf(fullCol) === -1) {
+      if (!builder.hasSelectionAs(fullCol, col)) {
+        if (selectionsToAdd.indexOf(fullCol) === -1) {
+          selectedProps.push(prop);
+          selectionsToAdd.push(fullCol);
+        }
+      } else if (joinOp && joinOp.releaseInternalRootSelection(col)) {
+        // The join operation no longer omits the column, so we need to
+        // omit the property once the relations have been fetched.
         selectedProps.push(prop);
-        selectionsToAdd.push(fullCol);
       }
     }
   }

package/lib/queryBuilder/operations/jsonApi/postgresJsonApi.js

@@ -44,10 +44,16 @@ const { asArray, isObject, isString } = require('../../../utils/objectUtils');
 
 function parseFieldExpression(expression, extractAsText) {
   let parsed = parser.parseFieldExpression(expression);
+  let middleQuotedColumnName = parsed.columnName.split('.').join('"."');
+  let column = `"${middleQuotedColumnName}"`;
+  // Reference the bare column when there is no json path, so that Postgres can
+  // use indexes on it. `#>> '{}'` is still needed to extract the value as text.
+  if (parsed.access.length === 0 && !extractAsText) {
+    return column;
+  }
   let jsonRefs = parsed.access.map((it) => it.ref).join(',');
   let extractor = extractAsText ? '#>>' : '#>';
-  let middleQuotedColumnName = parsed.columnName.split('.').join('"."');
-  return `"${middleQuotedColumnName}"${extractor}'{${jsonRefs}}'`;
+  return `${column}${extractor}'{${jsonRefs}}'`;
 }
 
 function whereJsonbRefOnLeftJsonbValOrRefOnRight(

package/lib/queryBuilder/transformations/WrapMysqlModifySubqueryTransformation.js

@@ -2,6 +2,8 @@
 
 const { QueryTransformation } = require('./QueryTransformation');
 const { isMySql } = require('../../utils/knexUtils');
+const { once } = require('../../utils/objectUtils');
+const getJoinBuilder = once(() => require('../JoinBuilder').JoinBuilder);
 
 /**
  * Mysql doesn't allow queries like this:
@@ -30,6 +32,13 @@ class WrapMysqlModifySubqueryTransformation extends QueryTransformation {
       return query;
     }
 
+    // This transformation should not apply to join builder, otherwise it causes:
+    // "TypeError: parentQuery.isUpdate is not a function"
+    const JoinBuilder = getJoinBuilder();
+    if (parentQuery instanceof JoinBuilder) {
+      return query;
+    }
+
     // This transformation only applies to update and delete queries.
     if (!parentQuery.isUpdate() && !parentQuery.isDelete()) {
       return query;

package/lib/relations/RelationProperty.js

@@ -184,14 +184,18 @@ function createRefs(refs) {
 
 function createPaths(refs, modelClassResolver) {
   return refs.map((ref) => {
-    if (!ref.tableName) {
+    // References created with `SomeModel.ref(column)` have no explicit table
+    // name, so fall back to the table name of their model class.
+    const tableName = ref.tableName || (ref.modelClass && ref.modelClass.getTableName());
+
+    if (!tableName) {
       throw new InvalidReferenceError();
     }
 
-    const modelClass = modelClassResolver(ref.tableName);
+    const modelClass = modelClassResolver(tableName);
 
     if (!modelClass) {
-      throw new ModelNotFoundError(ref.tableName);
+      throw new ModelNotFoundError(tableName);
     }
 
     const prop = modelClass.columnNameToPropertyName(ref.column);

package/lib/relations/belongsToOne/BelongsToOneInsertOperation.js

@@ -22,6 +22,7 @@ class BelongsToOneInsertOperation extends RelationInsertOperation {
     }
 
     const relateOp = new BelongsToOneRelateOperation('relate', {
+      dontCopyReturning: true,
       relation: this.relation,
       owner: this.owner,
     });

package/lib/relations/belongsToOne/BelongsToOneRelateOperation.js

@@ -35,6 +35,11 @@ class BelongsToOneRelateOperation extends RelateOperation {
       .query()
       .childQueryOf(builder)
       .patch(patch)
+      .modify((query) => {
+        if (!this.opt.dontCopyReturning) {
+          query.copyFrom(builder, /returning/);
+        }
+      })
       .whereInComposite(ownerIdProp.refs(builder), ownerIds);
   }
 }

package/lib/relations/hasMany/HasManyRelateOperation.js

@@ -28,6 +28,7 @@ class HasManyRelateOperation extends RelateOperation {
       .query()
       .childQueryOf(builder)
       .patch(patch)
+      .copyFrom(builder, /returning/)
       .copyFrom(builder, builder.constructor.JoinSelector)
       .copyFrom(builder, builder.constructor.WhereSelector)
       .findByIds(this.ids)

package/lib/relations/manyToMany/relate/ManyToManyRelateOperation.js

@@ -17,6 +17,7 @@ class ManyToManyRelateOperation extends RelateOperation {
     const joinModelClass = this.relation.getJoinModelClass(builder.knex());
     const ownerValues = this.owner.getSplitProps(builder, this.relation);
     const joinModels = [];
+    const isReturning = !this.opt.dontCopyReturning && builder.has(/returning/);
 
     for (const ownerValue of ownerValues) {
       for (const relatedValue of this.ids) {
@@ -43,6 +44,11 @@ class ManyToManyRelateOperation extends RelateOperation {
       })
       .insert(joinModels)
       .runAfter((models) => {
+        if (isReturning) {
+          // Return the inserted join rows if `returning` was used.
+          return models;
+        }
+
         return Array.isArray(models) ? models.length : 1;
       });
   }

package/lib/utils/identifierMapping.js

@@ -27,6 +27,7 @@ function snakeCase(
     upperCase = false,
     underscoreBeforeDigits = false,
     underscoreBetweenUppercaseLetters = false,
+    noDoubleUnderscores = false,
   } = {},
 ) {
   if (str.length === 0) {
@@ -48,11 +49,16 @@ function snakeCase(
     const lowerChar = lower[i];
     const prevLowerChar = lower[i - 1];
 
+    // If noDoubleUnderscores is true, never insert an underscore directly
+    // after an existing one (e.g. "foo_1" stays "foo_1" instead of becoming
+    // "foo__1" when underscoreBeforeDigits is true).
+    const canInsertUnderscore = !noDoubleUnderscores || prevChar !== '_';
+
     // If underScoreBeforeDigits is true then, well, insert an underscore
     // before digits :). Only the first digit gets an underscore if
     // there are multiple.
     if (underscoreBeforeDigits && isDigit(char) && !isDigit(prevChar)) {
-      out += '_' + char;
+      out += canInsertUnderscore ? '_' + char : char;
       continue;
     }
 
@@ -65,7 +71,7 @@ function snakeCase(
       // If underscoreBetweenUppercaseLetters is true, we always place an underscore
       // before consecutive uppercase letters (e.g. "fooBAR" becomes "foo_b_a_r").
       // Otherwise, we don't (e.g. "fooBAR" becomes "foo_bar").
-      if (underscoreBetweenUppercaseLetters || !prevCharacterIsUppercase) {
+      if (canInsertUnderscore && (underscoreBetweenUppercaseLetters || !prevCharacterIsUppercase)) {
         out += '_' + lowerChar;
       } else {
         out += lowerChar;

package/lib/utils/objectUtils.js

@@ -123,13 +123,17 @@ function union(arr1, arr2) {
 }
 
 function unionSmall(arr1, arr2) {
-  const all = arr1.slice();
+  const all = [];
 
-  for (let i = 0, l = arr2.length; i < l; ++i) {
-    const item = arr2[i];
+  for (let i = 0, l = arr1.length; i < l; ++i) {
+    if (all.indexOf(arr1[i]) === -1) {
+      all.push(arr1[i]);
+    }
+  }
 
-    if (all.indexOf(item) === -1) {
-      all.push(item);
+  for (let i = 0, l = arr2.length; i < l; ++i) {
+    if (all.indexOf(arr2[i]) === -1) {
+      all.push(arr2[i]);
     }
   }