objection 3.6.0 → 3.7.0

package/lib/relations/RelationFindOperation.js

@@ -12,7 +12,6 @@ class RelationFindOperation extends FindOperation {
     this.alwaysReturnArray = false;
     this.assignResultToOwner = true;
     this.relationProperty = opt.relationProperty || this.relation.name;
-    this.omitProps = [];
     this.alias = null;
   }
 
@@ -21,10 +20,9 @@ class RelationFindOperation extends FindOperation {
     this.relation.findQuery(builder, this.owner);
 
     if (this.owner.isModels) {
-      this.warnOnMissingOwnerProps();
+      this.warnOnInvalidOwnerProps();
 
       if (this.assignResultToOwner) {
-        this.warnOnArrayOwnerProps();
         this.selectMissingJoinColumns(builder);
       }
     }
@@ -70,11 +68,6 @@ class RelationFindOperation extends FindOperation {
 
   onAfter3(builder, related) {
     const isOneToOne = this.relation.isOneToOne();
-    const intOpt = builder.internalOptions();
-
-    if (!intOpt.keepImplicitJoinProps) {
-      this.omitImplicitJoinProps(related);
-    }
 
     if (!this.alwaysReturnArray && isOneToOne && related.length <= 1) {
       related = related[0] || undefined;
@@ -83,6 +76,14 @@ class RelationFindOperation extends FindOperation {
     return super.onAfter3(builder, related);
   }
 
+  warnOnInvalidOwnerProps() {
+    this.warnOnMissingOwnerProps();
+
+    if (this.assignResultToOwner) {
+      this.warnOnArrayOwnerProps();
+    }
+  }
+
   // Owner models without the join columns, e.g. loaded with a partial
   // `select()`, silently get no related models (#1832). Only `undefined`
   // is reported, as `null` is a legit value for a missing relation, and
@@ -111,7 +112,11 @@ class RelationFindOperation extends FindOperation {
   // assigned to their owners, so all owners silently get no related models
   // (#2667). `$relatedQuery()` without assigning the results isn't affected.
   warnOnArrayOwnerProps() {
-    const { ownerProp } = this.relation;
+    const { ownerProp, joinTable } = this.relation;
+    // Relations through a join table already are the alternative to arrays.
+    const advice = joinTable
+      ? 'Map the relation from a column that holds a single key instead.'
+      : 'Use a ManyToManyRelation through a join table instead.';
 
     for (let c = 0, lc = ownerProp.size; c < lc; ++c) {
       if (this.owner.modelArray.some((owner) => Array.isArray(ownerProp.getProp(owner, c)))) {
@@ -119,7 +124,7 @@ class RelationFindOperation extends FindOperation {
           `Fetching relation "${this.relation.name}" of ${this.relation.ownerModelClass.name}: ` +
             `the join property "${ownerProp.propDescription(c)}" of some owner models holds ` +
             'an array, which is not supported, so no related models are found for them. ' +
-            'Use a ManyToManyRelation through a join table instead.',
+            advice,
         );
       }
     }
@@ -154,7 +159,7 @@ class RelationFindOperation extends FindOperation {
       const col = relatedProp.cols[c];
 
       if (!builder.hasSelectionAs(fullCol, col) && addedSelects.indexOf(fullCol) === -1) {
-        this.omitProps.push(prop);
+        this.omitFromResult(builder, prop);
         addedSelects.push(fullCol);
       }
     }
@@ -170,34 +175,12 @@ class RelationFindOperation extends FindOperation {
     }
   }
 
-  omitImplicitJoinProps(related) {
-    const relatedModelClass = this.relation.relatedModelClass;
-
-    if (!this.omitProps.length || !related) {
-      return related;
-    }
-
-    if (!Array.isArray(related)) {
-      return this.omitImplicitJoinPropsFromOne(relatedModelClass, related);
-    }
-
-    if (!related.length) {
-      return related;
-    }
-
-    for (let i = 0, l = related.length; i < l; ++i) {
-      this.omitImplicitJoinPropsFromOne(relatedModelClass, related[i]);
-    }
-
-    return related;
-  }
-
-  omitImplicitJoinPropsFromOne(relatedModelClass, model) {
-    for (let c = 0, lc = this.omitProps.length; c < lc; ++c) {
-      relatedModelClass.omitImpl(model, this.omitProps[c]);
+  // Omits a property that was selected only to assign the related models to
+  // their owners from the result, before any `runAfter()` hooks are called.
+  omitFromResult(builder, prop) {
+    if (!builder.internalOptions().keepImplicitJoinProps) {
+      builder.addInternalSelection(prop);
     }
-
-    return model;
   }
 
   clone() {
@@ -206,7 +189,6 @@ class RelationFindOperation extends FindOperation {
     clone.alwaysReturnArray = this.alwaysReturnArray;
     clone.assignResultToOwner = this.assignResultToOwner;
     clone.relationProperty = this.relationProperty;
-    clone.omitProps = this.omitProps.slice();
     clone.alias = this.alias;
 
     return clone;

package/lib/relations/belongsToOne/BelongsToOneDeleteOperation.js

@@ -3,8 +3,10 @@
 const { RelationDeleteOperation } = require('../RelationDeleteOperation');
 
 class BelongsToOneDeleteOperation extends RelationDeleteOperation {
-  onAfter1(_, result) {
-    if (this.owner.isModels) {
+  onAfter1(builder, result) {
+    // A query resolved without executing it, e.g. with `none()`, deleted
+    // nothing, so the owners are left untouched.
+    if (this.owner.isModels && !builder.isExplicitlyResolvedOrRejected()) {
       const ownerProp = this.relation.ownerProp;
 
       for (const owner of this.owner.modelArray) {

package/lib/relations/manyToMany/ManyToManyModifyMixin.js

@@ -16,21 +16,27 @@ const ManyToManyModifyMixin = (Operation) => {
     constructor(...args) {
       super(...args);
       this.modifyFilterSubquery = null;
+      this.joinRowFilterSubquery = null;
       this.skipRelationFilter = false;
     }
 
-    // Updates of rows that are known to be related, like the patches of
-    // `upsertGraph()`, keep their own filters (#135).
+    // Unrelate doesn't execute the main query, and updates of rows that are
+    // known to be related, like the patches of `upsertGraph()`, keep their own
+    // filters (#135).
     get modifyMainQuery() {
-      return !this.skipRelationFilter;
+      return !this.modifiesJoinTableOnly && !this.skipRelationFilter;
     }
 
     // At this point `builder` should only have the user's own wheres and joins. There can
     // be other operations (like orderBy) too, but those are meaningless with modify operations.
     onBuild(builder) {
-      this.modifyFilterSubquery = this.createModifyFilterSubquery(builder);
+      if (this.modifiesJoinTable && !this.skipRelationFilter) {
+        this.joinRowFilterSubquery = this.createJoinRowFilterSubquery(builder);
+      }
 
       if (this.modifyMainQuery) {
+        this.modifyFilterSubquery = this.createModifyFilterSubquery(builder);
+
         // We can now remove the where and join statements from the main query.
         this.removeFiltersFromMainQuery(builder);
 
@@ -74,22 +80,39 @@ const ManyToManyModifyMixin = (Operation) => {
       return builder.whereInComposite(idRefs, subquery);
     }
 
-    // Modifies the join rows of all related rows that match the filters. If the filters
-    // reference join table columns, this also modifies join rows that don't match them
-    // but share a related row with one that does (#1853). The dialect specific mixins
-    // override this to only modify the join rows that match the filters themselves.
+    // Only modifies the join rows that match the filters (#1853).
     applyModifyFilterForJoinTable(builder) {
       const joinTableOwnerRefs = this.relation.joinTableOwnerProp.refs(builder);
-      const joinTableRelatedRefs = this.relation.joinTableRelatedProp.refs(builder);
-
-      const relatedRefs = this.relation.relatedProp.refs(builder);
       const ownerValues = this.owner.getProps(this.relation);
 
-      const subquery = this.modifyFilterSubquery.clone().select(relatedRefs);
-
       return builder
-        .whereInComposite(joinTableRelatedRefs, subquery)
-        .whereInComposite(joinTableOwnerRefs, ownerValues);
+        .whereInComposite(joinTableOwnerRefs, ownerValues)
+        .whereExists(this.joinRowFilterSubquery);
+    }
+
+    // Selects the related rows of a join row that match the filters. The join
+    // table isn't joined, so that the filters on its columns apply to the join
+    // row of the outer query.
+    createJoinRowFilterSubquery(builder) {
+      const { relation } = this;
+      const builderClass = builder.constructor;
+      const subquery = relation.relatedModelClass.query().childQueryOf(builder);
+      const joinTableRef = builder.tableRefFor(relation.joinTable);
+
+      addWhereGroup(subquery, () => {
+        relation.relatedProp.forEach((i) => {
+          const relatedRef = relation.relatedProp.ref(subquery, i);
+          const joinTableRelatedRef = relation.joinTableRelatedProp.ref(subquery, i);
+
+          subquery.where(relatedRef, joinTableRelatedRef.table(joinTableRef));
+        });
+      });
+
+      return relation
+        .applyModify(subquery)
+        .copyFrom(builder, builderClass.WhereSelector)
+        .copyFrom(builder, builderClass.JoinSelector)
+        .select(1);
     }
 
     toFindOperation() {
@@ -111,6 +134,7 @@ const ManyToManyModifyMixin = (Operation) => {
     clone() {
       const clone = super.clone();
       clone.modifyFilterSubquery = this.modifyFilterSubquery;
+      clone.joinRowFilterSubquery = this.joinRowFilterSubquery;
       clone.skipRelationFilter = this.skipRelationFilter;
       return clone;
     }

package/lib/relations/manyToMany/ManyToManyMySqlModifyMixin.js

@@ -1,66 +1,55 @@
 'use strict';
 
 const { ManyToManyModifyMixin } = require('./ManyToManyModifyMixin');
-const { isObject } = require('../../utils/objectUtils');
 
 // We need to override this mixin for mysql because mysql doesn't allow a
-// statement that modifies the join table to read the related table in a
-// subquery, if a trigger on the join table modifies the related table:
+// statement that modifies the join table to read the join table in a
+// subquery (ER_UPDATE_TABLE_USED), e.g. through the user's filters, or the
+// related table if a trigger on the join table modifies it
+// (ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG).
 //
-//   ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG
-//
-// So the join rows that match the filters are fetched in a separate query
-// before the main query, which then only modifies these rows (#1853). Mysql
-// has no row ids and the join table's primary key isn't known, so the rows are
-// identified by the values of all their columns.
+// So the owner and related ids of the join rows that match the filters are
+// fetched in a separate query before the statement, which then only modifies
+// the join rows with these ids. Unlike the subquery, these can't tell apart
+// join rows that only differ in their other columns (#1853).
 //
 // https://stackoverflow.com/a/2314264/3729316
 const ManyToManyMySqlModifyMixin = (Operation) => {
   return class extends ManyToManyModifyMixin(Operation) {
     applyModifyFilterForJoinTable(builder) {
-      const joinTableOwnerRefs = this.relation.joinTableOwnerProp.refs(builder);
-      const tableRef = builder.tableRefFor(this.relation.getJoinModelClass(builder));
-
+      const { joinTableOwnerProp, joinTableRelatedProp } = this.relation;
       const ownerValues = this.owner.getProps(this.relation);
-      const subquery = this.modifyFilterSubquery.clone().select(`${tableRef}.*`);
+      const subquery = this.joinRowFilterSubquery;
 
       return builder
+        .whereInComposite(joinTableOwnerProp.refs(builder), ownerValues)
         .runBefore(async (_, builder) => {
+          const idRefs = [
+            ...joinTableOwnerProp.refs(builder),
+            ...joinTableRelatedProp.refs(builder),
+          ];
+
           // Fetch the raw rows: no models, so that no hooks run for them.
-          const rows = await subquery.toKnexQuery();
+          const rows = await builder
+            .modelClass()
+            .query()
+            .childQueryOf(builder)
+            .copyFrom(builder, builder.constructor.WhereSelector)
+            .whereExists(subquery)
+            .select(idRefs)
+            .toKnexQuery();
 
-          if (rows.length) {
-            builder.where((builder) => {
-              for (const row of rows) {
-                builder.orWhere((builder) => {
-                  for (const [column, value] of Object.entries(row)) {
-                    builder.whereRaw('?? <=> ?', [
-                      `${tableRef}.${column}`,
-                      toComparableValue(value),
-                    ]);
-                  }
-                });
-              }
-            });
-          } else {
-            // Still execute the query so that it returns the expected
-            // result for the dialect, e.g. a count of 0 for deletes.
-            builder.where(false);
-          }
-        })
-        .whereInComposite(joinTableOwnerRefs, ownerValues);
+          // An empty list still executes the query, so that it returns the
+          // expected result for the dialect, e.g. a count of 0 for deletes.
+          builder.whereInComposite(
+            idRefs,
+            rows.map((row) => Object.values(row)),
+          );
+        });
     }
   };
 };
 
-// Some drivers return JSON columns parsed. Mysql parses strings that are
-// compared to JSON columns, so the stringified value matches them again.
-function toComparableValue(value) {
-  return isObject(value) && !(value instanceof Date) && !Buffer.isBuffer(value)
-    ? JSON.stringify(value)
-    : value;
-}
-
 module.exports = {
   ManyToManyMySqlModifyMixin,
 };

package/lib/relations/manyToMany/ManyToManyRelation.js

@@ -4,7 +4,7 @@ const { getModel } = require('../../model/getModel');
 const { Relation } = require('../Relation');
 const { RelationProperty } = require('../RelationProperty');
 
-const { isSqlite, isMySql, isPostgres } = require('../../utils/knexUtils');
+const { isSqlite, isMySql } = require('../../utils/knexUtils');
 const { inheritModel } = require('../../model/inheritModel');
 const { resolveModel } = require('../../utils/resolveModel');
 const { mapAfterAllReturn } = require('../../utils/promiseUtils');
@@ -21,14 +21,10 @@ const {
   ManyToManyUnrelateSqliteOperation,
 } = require('./unrelate/ManyToManyUnrelateSqliteOperation');
 const { ManyToManyUnrelateMySqlOperation } = require('./unrelate/ManyToManyUnrelateMySqlOperation');
-const {
-  ManyToManyUnrelatePostgresOperation,
-} = require('./unrelate/ManyToManyUnrelatePostgresOperation');
 
 const { ManyToManyUpdateOperation } = require('./update/ManyToManyUpdateOperation');
 const { ManyToManyUpdateSqliteOperation } = require('./update/ManyToManyUpdateSqliteOperation');
 const { ManyToManyUpdateMySqlOperation } = require('./update/ManyToManyUpdateMySqlOperation');
-const { ManyToManyUpdatePostgresOperation } = require('./update/ManyToManyUpdatePostgresOperation');
 
 const { ManyToManyDeleteOperation } = require('./delete/ManyToManyDeleteOperation');
 const { ManyToManyDeleteSqliteOperation } = require('./delete/ManyToManyDeleteSqliteOperation');
@@ -503,26 +499,25 @@ function parseBeforeInsert(ctx) {
 }
 
 function finalizeJoinModelClass(ctx) {
-  if (ctx.joinTableModelClass.getIdColumn() === null) {
-    // We cannot know if the join table has a primary key. Therefore we set some
-    // known column as the idColumn so that inserts will work.
+  // We cannot know if the join table has a primary key. Therefore we set some
+  // known column as the idColumn of the join model class that we created. A
+  // `through.modelClass` is left untouched, even if it has no `idColumn` (#2305).
+  if (!ctx.mapping.join.through.modelClass) {
     ctx.joinTableModelClass.idColumn = ctx.joinTableRelatedProp.cols;
   }
 
   return ctx;
 }
 
-// The modify operations need dialect specific code to only modify the join
-// rows that match the filters, see the `ManyToMany*ModifyMixin` classes.
-function getOperationClass(builder, { sqlite, mysql, postgres, other }) {
+// The modify operations need dialect specific code on sqlite and mysql, see
+// the `ManyToMany*ModifyMixin` classes.
+function getOperationClass(builder, { sqlite, mysql, other }) {
   const knex = builder.knex();
 
   if (isSqlite(knex)) {
     return sqlite;
   } else if (isMySql(knex)) {
     return mysql;
-  } else if (isPostgres(knex)) {
-    return postgres;
   } else {
     return other;
   }
@@ -532,7 +527,6 @@ function getUpdateOperationClass(builder) {
   return getOperationClass(builder, {
     sqlite: ManyToManyUpdateSqliteOperation,
     mysql: ManyToManyUpdateMySqlOperation,
-    postgres: ManyToManyUpdatePostgresOperation,
     other: ManyToManyUpdateOperation,
   });
 }
@@ -541,7 +535,6 @@ function getUnrelateOperationClass(builder) {
   return getOperationClass(builder, {
     sqlite: ManyToManyUnrelateSqliteOperation,
     mysql: ManyToManyUnrelateMySqlOperation,
-    postgres: ManyToManyUnrelatePostgresOperation,
     other: ManyToManyUnrelateOperation,
   });
 }
@@ -551,7 +544,6 @@ function getDeleteOperationClass(builder) {
   return getOperationClass(builder, {
     sqlite: ManyToManyDeleteSqliteOperation,
     mysql: ManyToManyDeleteOperation,
-    postgres: ManyToManyDeleteOperation,
     other: ManyToManyDeleteOperation,
   });
 }

package/lib/relations/manyToMany/ManyToManySqliteModifyMixin.js

@@ -15,19 +15,6 @@ const ManyToManySqliteModifyMixin = (Operation) => {
 
       return builder.whereInComposite(rowIdRef, subquery);
     }
-
-    applyModifyFilterForJoinTable(builder) {
-      const joinTableOwnerRefs = this.relation.joinTableOwnerProp.refs(builder);
-      const tableRef = builder.tableRefFor(this.relation.getJoinModelClass(builder));
-      const rowIdRef = `${tableRef}.${SQLITE_BUILTIN_ROW_ID}`;
-
-      const ownerValues = this.owner.getProps(this.relation);
-      const subquery = this.modifyFilterSubquery.clone().select(rowIdRef);
-
-      return builder
-        .whereInComposite(rowIdRef, subquery)
-        .whereInComposite(joinTableOwnerRefs, ownerValues);
-    }
   };
 };
 

package/lib/relations/manyToMany/find/ManyToManyFindOperation.js

@@ -36,7 +36,7 @@ class ManyToManyFindOperation extends RelationFindOperation {
     }
 
     if (this.owner.isModels) {
-      this.warnOnMissingOwnerProps();
+      this.warnOnInvalidOwnerProps();
 
       if (this.assignResultToOwner) {
         this.selectMissingJoinColumns(builder);
@@ -122,8 +122,7 @@ class ManyToManyFindOperation extends RelationFindOperation {
       const propName = relatedModelClass.columnNameToPropertyName(this.ownerJoinColumnAlias[i]);
 
       builder.select(joinTableOwnerRef.as(this.ownerJoinColumnAlias[i]));
-      // Mark them to be omitted later.
-      this.omitProps.push(propName);
+      this.omitFromResult(builder, propName);
     });
 
     super.selectMissingJoinColumns(builder);

package/lib/relations/manyToMany/unrelate/ManyToManyUnrelateMySqlOperation.js

@@ -5,11 +5,7 @@ const { ManyToManyMySqlModifyMixin } = require('../ManyToManyMySqlModifyMixin');
 
 class ManyToManyUnrelateMySqlOperation extends ManyToManyMySqlModifyMixin(
   ManyToManyUnrelateOperationBase,
-) {
-  get modifyMainQuery() {
-    return false;
-  }
-}
+) {}
 
 module.exports = {
   ManyToManyUnrelateMySqlOperation,

package/lib/relations/manyToMany/unrelate/ManyToManyUnrelateOperation.js

@@ -3,11 +3,7 @@
 const { ManyToManyUnrelateOperationBase } = require('./ManyToManyUnrelateOperationBase');
 const { ManyToManyModifyMixin } = require('../ManyToManyModifyMixin');
 
-class ManyToManyUnrelateOperation extends ManyToManyModifyMixin(ManyToManyUnrelateOperationBase) {
-  get modifyMainQuery() {
-    return false;
-  }
-}
+class ManyToManyUnrelateOperation extends ManyToManyModifyMixin(ManyToManyUnrelateOperationBase) {}
 
 module.exports = {
   ManyToManyUnrelateOperation,

package/lib/relations/manyToMany/unrelate/ManyToManyUnrelateOperationBase.js

@@ -4,6 +4,15 @@ const { UnrelateOperation } = require('../../../queryBuilder/operations/Unrelate
 const { addWhereGroup } = require('../../../queryBuilder/whereGroups');
 
 class ManyToManyUnrelateOperationBase extends UnrelateOperation {
+  get modifiesJoinTable() {
+    return true;
+  }
+
+  // The main query is replaced by the query that `queryExecutor()` returns.
+  get modifiesJoinTableOnly() {
+    return true;
+  }
+
   queryExecutor(builder) {
     const unrelateQuery = this.relation
       .getJoinModelClass(builder.knex())

package/lib/relations/manyToMany/unrelate/ManyToManyUnrelateSqliteOperation.js

@@ -5,11 +5,7 @@ const { ManyToManySqliteModifyMixin } = require('../ManyToManySqliteModifyMixin'
 
 class ManyToManyUnrelateSqliteOperation extends ManyToManySqliteModifyMixin(
   ManyToManyUnrelateOperationBase,
-) {
-  get modifyMainQuery() {
-    return false;
-  }
-}
+) {}
 
 module.exports = {
   ManyToManyUnrelateSqliteOperation,

package/lib/relations/manyToMany/update/ManyToManyUpdateOperationBase.js

@@ -15,6 +15,10 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
     this.joinTablePatchFilterQuery = null;
   }
 
+  get modifiesJoinTable() {
+    return this.hasExtraProps;
+  }
+
   onAdd(builder, args) {
     const obj = args[0];
 
@@ -47,7 +51,9 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
   }
 
   async onAfter1(builder, result) {
-    if (this.hasExtraProps) {
+    // A query resolved without updating anything, e.g. with `none()`, leaves
+    // the join rows untouched too.
+    if (this.hasExtraProps && !this.isResolvedWithoutUpdate(builder)) {
       const joinTableUpdateQuery = this.relation
         .getJoinModelClass(builder.knex())
         .query()

package/lib/utils/identifierMapping.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { isObject, isPlainObject } = require('./objectUtils');
+const { isObject } = require('./objectUtils');
 
 // Super fast memoize for single argument functions.
 function memoize(func) {
@@ -149,9 +149,8 @@ function mapLastPart(mapper, separator) {
 }
 
 // Returns a function that takes an object as an input and maps the object's keys
-// using `mapper`, and its values using the optional `valueMapper`. If the input
-// is not an object, the input is returned unchanged.
-function keyMapper(mapper, valueMapper) {
+// using `mapper`. If the input is not an object, the input is returned unchanged.
+function keyMapper(mapper) {
   return (obj) => {
     if (!isObject(obj) || Array.isArray(obj)) {
       return obj;
@@ -162,7 +161,7 @@ function keyMapper(mapper, valueMapper) {
 
     for (let i = 0, l = keys.length; i < l; ++i) {
       const key = keys[i];
-      out[mapper(key)] = valueMapper ? valueMapper(obj[key]) : obj[key];
+      out[mapper(key)] = obj[key];
     }
 
     return out;
@@ -190,16 +189,10 @@ function snakeCaseMappers(opt = {}) {
   };
 }
 
-function knexIdentifierMappers({ parse, format, idSeparator = ':', mapNestedKeys = false } = {}) {
+function knexIdentifierMappers({ parse, format, idSeparator = ':' } = {}) {
   const formatId = memoize(mapLastPart(format, idSeparator));
   const parseId = memoize(mapLastPart(parse, idSeparator));
   const parseKeys = keyMapper(parseId);
-  // With `mapNestedKeys`, also map the keys of plain objects one level down, as
-  // in the rows knex returns with its `nestTables: true` option on MySQL:
-  // `{ tableName: { columnName: value } }`.
-  const parseRow = mapNestedKeys
-    ? keyMapper(parseId, (value) => (isPlainObject(value) ? parseKeys(value) : value))
-    : parseKeys;
 
   return {
     wrapIdentifier(identifier, origWrap) {
@@ -211,12 +204,12 @@ function knexIdentifierMappers({ parse, format, idSeparator = ':', mapNestedKeys
         const output = new Array(result.length);
 
         for (let i = 0, l = result.length; i < l; ++i) {
-          output[i] = parseRow(result[i]);
+          output[i] = parseKeys(result[i]);
         }
 
         return output;
       } else {
-        return parseRow(result);
+        return parseKeys(result);
       }
     },
   };
@@ -226,11 +219,10 @@ function knexSnakeCaseMappers(opt = {}) {
   return knexIdentifierMappers({
     parse: (str) => camelCase(str, opt),
     format: (str) => snakeCase(str, opt),
-    mapNestedKeys: opt.mapNestedKeys,
   });
 }
 
-function knexIdentifierMapping(colToProp, { mapNestedKeys } = {}) {
+function knexIdentifierMapping(colToProp) {
   const propToCol = Object.keys(colToProp).reduce((propToCol, column) => {
     propToCol[colToProp[column]] = column;
     return propToCol;
@@ -239,7 +231,6 @@ function knexIdentifierMapping(colToProp, { mapNestedKeys } = {}) {
   return knexIdentifierMappers({
     parse: (column) => colToProp[column] || column,
     format: (prop) => propToCol[prop] || prop,
-    mapNestedKeys,
   });
 }