objection 3.9.1 → 4.0.0-rc.1

package/lib/objection.js

@@ -1,6 +1,10 @@
-'use strict';
+import { Model as NativeModel } from './model/Model.js';
+import { QueryBuilder as NativeQueryBuilder } from './queryBuilder/QueryBuilder.js';
+import { AjvValidator as NativeAjvValidator } from './model/AjvValidator.js';
+import { Validator as NativeValidator } from './model/Validator.js';
+import { inherit } from './utils/classUtils.js';
 
-const {
+export {
   DBError,
   UniqueViolationError,
   NotNullViolationError,
@@ -8,55 +12,51 @@ const {
   ConstraintViolationError,
   CheckViolationError,
   DataError,
-} = require('db-errors');
-const { Model: NativeModel } = require('./model/Model');
-const { QueryBuilder: NativeQueryBuilder } = require('./queryBuilder/QueryBuilder');
-const { QueryBuilderBase } = require('./queryBuilder/QueryBuilderBase');
-const { QueryBuilderOperation } = require('./queryBuilder/operations/QueryBuilderOperation');
-const { RelationExpression } = require('./queryBuilder/RelationExpression');
-const { ValidationError } = require('./model/ValidationError');
-const { NotFoundError } = require('./model/NotFoundError');
-const { AjvValidator: NativeAjvValidator } = require('./model/AjvValidator');
-const { Validator: NativeValidator } = require('./model/Validator');
-const { Relation } = require('./relations/Relation');
-const { HasOneRelation } = require('./relations/hasOne/HasOneRelation');
-const { HasManyRelation } = require('./relations/hasMany/HasManyRelation');
-const { BelongsToOneRelation } = require('./relations/belongsToOne/BelongsToOneRelation');
-const { HasOneThroughRelation } = require('./relations/hasOneThrough/HasOneThroughRelation');
-const { ManyToManyRelation } = require('./relations/manyToMany/ManyToManyRelation');
-const { transaction } = require('./transaction');
-const { initialize } = require('./initialize');
-
-const {
+} from './dbErrors/index.js';
+export { QueryBuilderBase } from './queryBuilder/QueryBuilderBase.js';
+export { QueryBuilderOperation } from './queryBuilder/operations/QueryBuilderOperation.js';
+export { RelationExpression } from './queryBuilder/RelationExpression.js';
+export { ValidationError } from './model/ValidationError.js';
+export { NotFoundError } from './model/NotFoundError.js';
+export { Relation } from './relations/Relation.js';
+export { HasOneRelation } from './relations/hasOne/HasOneRelation.js';
+export { HasManyRelation } from './relations/hasMany/HasManyRelation.js';
+export { BelongsToOneRelation } from './relations/belongsToOne/BelongsToOneRelation.js';
+export { HasOneThroughRelation } from './relations/hasOneThrough/HasOneThroughRelation.js';
+export { ManyToManyRelation } from './relations/manyToMany/ManyToManyRelation.js';
+export { BelongsToManyRelation } from './relations/belongsToMany/BelongsToManyRelation.js';
+export { transaction } from './transaction.js';
+export { initialize } from './initialize.js';
+export {
   snakeCaseMappers,
   knexSnakeCaseMappers,
   knexIdentifierMapping,
-} = require('./utils/identifierMapping');
-const { compose, mixin } = require('./utils/mixin');
-const { ref } = require('./queryBuilder/ReferenceBuilder');
-const { val } = require('./queryBuilder/ValueBuilder');
-const { raw } = require('./queryBuilder/RawBuilder');
-const { fn } = require('./queryBuilder/FunctionBuilder');
-const { inherit } = require('../lib/utils/classUtils');
+} from './utils/identifierMapping.js';
+export { compose, mixin } from './utils/mixin.js';
+export { asArray } from './utils/objectUtils.js';
+export { ref } from './queryBuilder/ReferenceBuilder.js';
+export { val } from './queryBuilder/ValueBuilder.js';
+export { raw } from './queryBuilder/RawBuilder.js';
+export { fn } from './queryBuilder/FunctionBuilder.js';
 
 // We need to wrap the classes, that people can inherit, with ES5 classes
 // so that babel is able to use ES5 inheritance. sigh... Maybe people
 // should stop transpiling node apps to ES5 in the year 2019? Node 6
 // with full class support was released three years ago.
 
-function Model() {
+export function Model() {
   // Nothing to do here.
 }
 
-function QueryBuilder(...args) {
+export function QueryBuilder(...args) {
   NativeQueryBuilder.init(this, ...args);
 }
 
-function Validator(...args) {
+export function Validator(...args) {
   NativeValidator.init(this, ...args);
 }
 
-function AjvValidator(...args) {
+export function AjvValidator(...args) {
   NativeAjvValidator.init(this, ...args);
 }
 
@@ -66,41 +66,3 @@ inherit(Validator, NativeValidator);
 inherit(AjvValidator, NativeAjvValidator);
 
 Model.QueryBuilder = QueryBuilder;
-
-module.exports = {
-  Model,
-  QueryBuilder,
-  QueryBuilderBase,
-  QueryBuilderOperation,
-  RelationExpression,
-  ValidationError,
-  NotFoundError,
-  AjvValidator,
-  Validator,
-  Relation,
-  HasOneRelation,
-  HasManyRelation,
-  BelongsToOneRelation,
-  HasOneThroughRelation,
-  ManyToManyRelation,
-
-  transaction,
-  initialize,
-  compose,
-  mixin,
-  ref,
-  val,
-  raw,
-  fn,
-  snakeCaseMappers,
-  knexSnakeCaseMappers,
-  knexIdentifierMapping,
-
-  DBError,
-  UniqueViolationError,
-  NotNullViolationError,
-  ForeignKeyViolationError,
-  ConstraintViolationError,
-  CheckViolationError,
-  DataError,
-};

package/lib/queryBuilder/FunctionBuilder.js

@@ -1,11 +1,9 @@
-'use strict';
+import { RawBuilder, normalizeRawArgs } from './RawBuilder.js';
+import { asSingle, isNumber } from '../utils/objectUtils.js';
 
-const { RawBuilder, normalizeRawArgs } = require('./RawBuilder');
-const { asSingle, isNumber } = require('../utils/objectUtils');
+export class FunctionBuilder extends RawBuilder {}
 
-class FunctionBuilder extends RawBuilder {}
-
-function fn(...argsIn) {
+export function fn(...argsIn) {
   const { sql, args } = normalizeRawArgs(argsIn);
   return new FunctionBuilder(`${sql}(${args.map(() => '?').join(', ')})`, args);
 }
@@ -27,8 +25,3 @@ fn.now = (precision) => {
   // injection here.
   return new FunctionBuilder(`CURRENT_TIMESTAMP(${precision})`, []);
 };
-
-module.exports = {
-  FunctionBuilder,
-  fn,
-};

package/lib/queryBuilder/InternalOptions.js

@@ -1,12 +1,11 @@
-'use strict';
-
-class InternalOptions {
+export class InternalOptions {
   constructor() {
-    this.skipUndefined = false;
     this.keepImplicitJoinProps = false;
     this.returnImmediatelyValue = undefined;
     this.isInternalQuery = false;
     this.skipRelationFilter = false;
+    // The join table extras that related updates write, all of them if null:
+    this.joinTableExtras = null;
     this.debug = false;
     this.schema = undefined;
   }
@@ -14,18 +13,14 @@ class InternalOptions {
   clone() {
     const copy = new this.constructor();
 
-    copy.skipUndefined = this.skipUndefined;
     copy.keepImplicitJoinProps = this.keepImplicitJoinProps;
     copy.returnImmediatelyValue = this.returnImmediatelyValue;
     copy.isInternalQuery = this.isInternalQuery;
     copy.skipRelationFilter = this.skipRelationFilter;
+    copy.joinTableExtras = this.joinTableExtras;
     copy.debug = this.debug;
     copy.schema = this.schema;
 
     return copy;
   }
 }
-
-module.exports = {
-  InternalOptions,
-};

package/lib/queryBuilder/JoinBuilder.js

@@ -1,9 +1,8 @@
-'use strict';
+import { QueryBuilderOperationSupport } from './QueryBuilderOperationSupport.js';
+import { KnexOperation } from './operations/KnexOperation.js';
+import { setJoinBuilder } from './getJoinBuilder.js';
 
-const { QueryBuilderOperationSupport } = require('./QueryBuilderOperationSupport');
-const { KnexOperation } = require('./operations/KnexOperation');
-
-class JoinBuilder extends QueryBuilderOperationSupport {
+export class JoinBuilder extends QueryBuilderOperationSupport {
   using(...args) {
     return this.addOperation(new KnexOperation('using'), args);
   }
@@ -137,6 +136,4 @@ class JoinBuilder extends QueryBuilderOperationSupport {
   }
 }
 
-module.exports = {
-  JoinBuilder,
-};
+setJoinBuilder(JoinBuilder);

package/lib/queryBuilder/QueryBuilder.js

@@ -1,58 +1,63 @@
-'use strict';
-
-const { wrapDbError } = require('../utils/wrapDbError');
-
-const { raw } = require('./RawBuilder');
-const { createModifier } = require('../utils/createModifier');
-const { ValidationErrorType } = require('../model/ValidationError');
-const { isObject, isString, isFunction, last, flatten } = require('../utils/objectUtils');
-const { RelationExpression, DuplicateRelationError } = require('./RelationExpression');
-const { assertIdNotUndefined, assertHasIdColumn } = require('../utils/assert');
-const { warnOnce } = require('../utils/warnings');
-const { isMsSql } = require('../utils/knexUtils');
-
-const { Selection, isSameIdentifier } = require('./operations/select/Selection');
-
-const { QueryBuilderContext } = require('./QueryBuilderContext');
-const { QueryBuilderBase } = require('./QueryBuilderBase');
-
-const { FindOperation } = require('./operations/FindOperation');
-const { DeleteOperation } = require('./operations/DeleteOperation');
-const { UpdateOperation } = require('./operations/UpdateOperation');
-const { InsertOperation } = require('./operations/InsertOperation');
-const { RelateOperation } = require('./operations/RelateOperation');
-const { UnrelateOperation } = require('./operations/UnrelateOperation');
-
-const { JoinEagerOperation } = require('./operations/eager/JoinEagerOperation');
-const { NaiveEagerOperation } = require('./operations/eager/NaiveEagerOperation');
-const { WhereInEagerOperation } = require('./operations/eager/WhereInEagerOperation');
-
-const { InsertGraphAndFetchOperation } = require('./operations/InsertGraphAndFetchOperation');
-const { UpsertGraphAndFetchOperation } = require('./operations/UpsertGraphAndFetchOperation');
-const { InsertAndFetchOperation } = require('./operations/InsertAndFetchOperation');
-const { UpdateAndFetchOperation } = require('./operations/UpdateAndFetchOperation');
-const { JoinRelatedOperation } = require('./operations/JoinRelatedOperation');
-const { OnBuildKnexOperation } = require('./operations/OnBuildKnexOperation');
-const { InsertGraphOperation } = require('./operations/InsertGraphOperation');
-const { UpsertGraphOperation } = require('./operations/UpsertGraphOperation');
-const { RunBeforeOperation } = require('./operations/RunBeforeOperation');
-const { RunAfterOperation } = require('./operations/RunAfterOperation');
-const { FindByIdOperation } = require('./operations/FindByIdOperation');
-const { FindByIdsOperation } = require('./operations/FindByIdsOperation');
-const { OnBuildOperation } = require('./operations/OnBuildOperation');
-const { OnErrorOperation } = require('./operations/OnErrorOperation');
-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 { LimitPerParentOperation } = require('./operations/LimitPerParentOperation');
-const { FromOperation } = require('./operations/FromOperation');
-const { KnexOperation } = require('./operations/KnexOperation');
-const { clearUnsupportedOrder } = require('./withoutOrder');
-const { addWhereGroup } = require('./whereGroups');
-
-class QueryBuilder extends QueryBuilderBase {
+import { wrapError } from '../dbErrors/index.js';
+
+import { raw } from './RawBuilder.js';
+import { createModifier } from '../utils/createModifier.js';
+import { ValidationErrorType } from '../model/ValidationError.js';
+import { isObject, isString, isFunction, last, flatten } from '../utils/objectUtils.js';
+import {
+  RelationExpression,
+  DuplicateRelationError,
+  MisplacedTokenError,
+} from './RelationExpression.js';
+import { assertIdNotUndefined, assertHasIdColumn } from '../utils/assert.js';
+import { warnOnce } from '../utils/warnings.js';
+import { isMsSql } from '../utils/knexUtils.js';
+
+import { Selection, isSameIdentifier } from './operations/select/Selection.js';
+
+import { QueryBuilderContext } from './QueryBuilderContext.js';
+import { QueryBuilderBase } from './QueryBuilderBase.js';
+import { StaticHookArguments, isGraphQuery } from './StaticHookArguments.js';
+
+import { FindOperation } from './operations/FindOperation.js';
+import { DeleteOperation } from './operations/DeleteOperation.js';
+import { UpdateOperation } from './operations/UpdateOperation.js';
+import { InsertOperation } from './operations/InsertOperation.js';
+import { RelateOperation } from './operations/RelateOperation.js';
+import { UnrelateOperation } from './operations/UnrelateOperation.js';
+
+import { JoinEagerOperation } from './operations/eager/JoinEagerOperation.js';
+import { NaiveEagerOperation } from './operations/eager/NaiveEagerOperation.js';
+import { WhereInEagerOperation } from './operations/eager/WhereInEagerOperation.js';
+
+import { InsertGraphAndFetchOperation } from './operations/InsertGraphAndFetchOperation.js';
+import { UpsertGraphAndFetchOperation } from './operations/UpsertGraphAndFetchOperation.js';
+import { InsertAndFetchOperation } from './operations/InsertAndFetchOperation.js';
+import { UpdateAndFetchOperation } from './operations/UpdateAndFetchOperation.js';
+import { JoinRelatedOperation } from './operations/JoinRelatedOperation.js';
+import { OnBuildKnexOperation } from './operations/OnBuildKnexOperation.js';
+import { InsertGraphOperation } from './operations/InsertGraphOperation.js';
+import { UpsertGraphOperation } from './operations/UpsertGraphOperation.js';
+import { RunBeforeOperation } from './operations/RunBeforeOperation.js';
+import { RunAfterOperation } from './operations/RunAfterOperation.js';
+import { FindByIdOperation } from './operations/FindByIdOperation.js';
+import { FindByIdsOperation } from './operations/FindByIdsOperation.js';
+import { OnBuildOperation } from './operations/OnBuildOperation.js';
+import { OnErrorOperation } from './operations/OnErrorOperation.js';
+import { SelectOperation } from './operations/select/SelectOperation.js';
+import { EagerOperation } from './operations/eager/EagerOperation.js';
+import { RangeOperation } from './operations/RangeOperation.js';
+import { FirstOperation } from './operations/FirstOperation.js';
+import { NoneOperation } from './operations/NoneOperation.js';
+import { LimitPerParentOperation } from './operations/LimitPerParentOperation.js';
+import { FromOperation } from './operations/FromOperation.js';
+import { KnexOperation } from './operations/KnexOperation.js';
+import { clearUnsupportedOrder } from './withoutOrder.js';
+// Loaded for its side effect: it registers itself for `getJoinBuilder()`, which
+// the operations use to convert join callbacks.
+import './JoinBuilder.js';
+
+export class QueryBuilder extends QueryBuilderBase {
   static init(self, modelClass) {
     super.init(self, modelClass);
 
@@ -64,6 +69,7 @@ class QueryBuilder extends QueryBuilderBase {
 
     self._allowedGraphExpression = null;
     self._graphModifiersAtPath = [];
+    self._joinModifiersAtPath = [];
     // The eager algorithm that was most recently used explicitly, see `withGraph()`.
     self._graphAlgorithm = null;
     self._isJoinChildQuery = false;
@@ -332,6 +338,15 @@ class QueryBuilder extends QueryBuilderBase {
     return this;
   }
 
+  joinModifiersAtPath() {
+    return this._joinModifiersAtPath;
+  }
+
+  modifyJoin(path, modifier) {
+    this._joinModifiersAtPath.push({ path: RelationExpression.create(path), modifier });
+    return this;
+  }
+
   findOptions(opt) {
     if (arguments.length !== 0) {
       this._findOperationOptions = Object.assign({}, this._findOperationOptions, opt);
@@ -434,6 +449,7 @@ class QueryBuilder extends QueryBuilderBase {
 
     builder._allowedGraphExpression = this._allowedGraphExpression;
     builder._graphModifiersAtPath = this._graphModifiersAtPath.slice();
+    builder._joinModifiersAtPath = this._joinModifiersAtPath.slice();
     builder._graphAlgorithm = this._graphAlgorithm;
     builder._isJoinChildQuery = this._isJoinChildQuery;
     builder._findOperationOptions = this._findOperationOptions;
@@ -1023,35 +1039,21 @@ class QueryBuilder extends QueryBuilderBase {
   }
 
   updateById(id, modelOrObject) {
-    // Keep the id condition in its own where group, so that a user's `orWhere()`
-    // can't get around it. See `whereGroups.js`.
-    return addWhereGroup(this, () => this.findById(id))
+    return this.findById(id)
       .update(modelOrObject)
-      .runBefore((_, builder) => {
-        if (!builder.internalOptions().skipUndefined) {
-          assertIdNotUndefined(id, `undefined was passed to updateById`);
-        }
-      });
+      .runBefore(() => assertIdNotUndefined(id, `undefined was passed to updateById`));
   }
 
   patchById(id, modelOrObject) {
-    return addWhereGroup(this, () => this.findById(id))
+    return this.findById(id)
       .patch(modelOrObject)
-      .runBefore((_, builder) => {
-        if (!builder.internalOptions().skipUndefined) {
-          assertIdNotUndefined(id, `undefined was passed to patchById`);
-        }
-      });
+      .runBefore(() => assertIdNotUndefined(id, `undefined was passed to patchById`));
   }
 
   deleteById(id) {
-    return addWhereGroup(this, () => this.findById(id))
+    return this.findById(id)
       .delete()
-      .runBefore((_, builder) => {
-        if (!builder.internalOptions().skipUndefined) {
-          assertIdNotUndefined(id, `undefined was passed to deleteById`);
-        }
-      });
+      .runBefore(() => assertIdNotUndefined(id, `undefined was passed to deleteById`));
   }
 
   findById(...args) {
@@ -1318,17 +1320,13 @@ function parseRelationExpression(modelClass, exp) {
   try {
     return RelationExpression.create(exp);
   } catch (err) {
-    if (err instanceof DuplicateRelationError) {
-      throw modelClass.createValidationError({
-        type: ValidationErrorType.RelationExpression,
-        message: `Duplicate relation name "${err.relationName}" in relation expression "${exp}". For example, use "${err.relationName}.[foo, bar]" instead of "[${err.relationName}.foo, ${err.relationName}.bar]".`,
-      });
-    } else {
-      throw modelClass.createValidationError({
-        type: ValidationErrorType.RelationExpression,
-        message: `Invalid relation expression "${exp}"`,
-      });
-    }
+    throw modelClass.createValidationError({
+      type: ValidationErrorType.RelationExpression,
+      message:
+        err instanceof DuplicateRelationError || err instanceof MisplacedTokenError
+          ? `Invalid relation expression "${exp}": ${err.message}`
+          : `Invalid relation expression "${exp}"`,
+    });
   }
 }
 
@@ -1465,15 +1463,51 @@ function afterExecute(builder, result) {
   promise = chainOperationHooks(promise, builder, 'onAfter1');
   promise = chainOperationHooks(promise, builder, 'onAfter2');
   promise = promise.then((result) => omitInternalSelections(builder, result));
+  promise = chainOperationHooks(promise, builder, 'onAfter3');
+  promise = promise.then((result) => callStaticAfterHook(builder, result));
 
   promise = chainHooks(promise, builder, builder.context().runAfter);
   promise = chainHooks(promise, builder, builder.internalContext().runAfter);
-
-  promise = chainOperationHooks(promise, builder, 'onAfter3');
+  promise = chainHooks(promise, builder, getRunAfterFuncs(builder));
 
   return promise;
 }
 
+// Call the static after hook of the model class with the value that the query
+// returns, once its shape is final.
+async function callStaticAfterHook(builder, result) {
+  const modelClass = builder.modelClass();
+  let afterHook = null;
+
+  if (isGraphQuery(builder)) {
+    // Leave the hooks to the queries that the graph runs.
+  } else if (builder.isInsert()) {
+    afterHook = modelClass.afterInsert;
+  } else if (builder.isUpdate()) {
+    afterHook = modelClass.afterUpdate;
+  } else if (builder.isDelete()) {
+    afterHook = modelClass.afterDelete;
+  } else if (builder.isFind() && !builder.findOptions().dontCallFindHooks) {
+    afterHook = modelClass.afterFind;
+  }
+
+  if (afterHook) {
+    const args = StaticHookArguments.create({ builder, result });
+    const maybeResult = await afterHook.call(modelClass, args);
+    return maybeResult === undefined ? result : maybeResult;
+  } else {
+    return result;
+  }
+}
+
+// The callbacks of `runAfter()`, and the ones that `range()`, `throwIfNotFound()`
+// and `traverse()` add, in the order they were added to the query:
+function getRunAfterFuncs(builder) {
+  const funcs = [];
+  builder.forEachOperation(RunAfterOperation, (op) => funcs.push(op.func));
+  return funcs;
+}
+
 function omitInternalSelections(builder, result) {
   const props = builder._internalSelections;
 
@@ -1508,7 +1542,7 @@ function handleExecuteError(builder, err) {
     return Promise.resolve(err.value);
   }
 
-  let promise = Promise.reject(wrapDbError(err));
+  let promise = Promise.reject(wrapError(err));
 
   builder.forEachOperation(true, (op) => {
     if (op.hasOnError()) {
@@ -1714,15 +1748,16 @@ function createModels(result, builder) {
   }
 
   const modelClass = builder.resultModelClass();
+  const options = { knex: builder.knex() };
 
   if (Array.isArray(result)) {
     if (result.length && shouldBeConvertedToModel(result[0], modelClass)) {
       for (let i = 0, l = result.length; i < l; ++i) {
-        result[i] = modelClass.fromDatabaseJson(result[i]);
+        result[i] = modelClass.fromDatabaseJson(result[i], options);
       }
     }
   } else if (shouldBeConvertedToModel(result, modelClass)) {
-    result = modelClass.fromDatabaseJson(result);
+    result = modelClass.fromDatabaseJson(result, options);
   }
 
   return result;
@@ -1781,7 +1816,3 @@ function unrelateOperationFactory() {
 function deleteOperationFactory() {
   return new DeleteOperation('delete');
 }
-
-module.exports = {
-  QueryBuilder,
-};