objection 3.3.0 → 3.4.1

package/lib/model/AjvValidator.js

@@ -6,6 +6,7 @@ const { Validator } = require('./Validator');
 const { ValidationErrorType } = require('../model/ValidationError');
 const { isObject, once, cloneDeep: lodashCloneDeep, omit } = require('../utils/objectUtils');
 const { parseFieldExpression } = require('../utils/parseFieldExpression');
+const { getQueryPropKeys } = require('./modelQueryProps');
 
 class AjvValidator extends Validator {
   static init(self, conf) {
@@ -51,6 +52,10 @@ class AjvValidator extends Validator {
 
     setupAjv(self.ajv);
     setupAjv(self.ajvNoDefaults);
+
+    // Created when needed by `compileQueryPropValidator()`.
+    self.ajvQueryProps = null;
+    self.setupAjv = setupAjv;
   }
 
   beforeValidate({ json, model, options, ctx }) {
@@ -75,7 +80,12 @@ class AjvValidator extends Validator {
     }
 
     const modelClass = model.constructor;
-    const validator = this.getValidator(modelClass, ctx.jsonSchema, !!options.patch);
+    const validator = this.getValidator(
+      modelClass,
+      ctx.jsonSchema,
+      !!options.patch,
+      options.patch ? null : getMissingQueryPropKeys(model, json, ctx.jsonSchema),
+    );
 
     // We need to clone the input json if we are about to set default values.
     if (!options.mutable && !options.patch && setsDefaultValues(ctx.jsonSchema)) {
@@ -103,7 +113,7 @@ class AjvValidator extends Validator {
     return json;
   }
 
-  getValidator(modelClass, jsonSchema, isPatchObject) {
+  getValidator(modelClass, jsonSchema, isPatchObject, queryPropKeys = null) {
     // Use the Ajv custom serializer if provided.
     const createCacheKey = this.ajvOptions.serialize || JSON.stringify;
 
@@ -136,6 +146,10 @@ class AjvValidator extends Validator {
 
         // Validator created for the unmodified schema.
         normalValidator: null,
+
+        // Validators created for the schema object without the `required`
+        // properties that are given as query properties, keyed by their names.
+        queryPropValidators: null,
       };
 
       this.cache.set(cacheKey, validators);
@@ -148,6 +162,17 @@ class AjvValidator extends Validator {
         validator = this.compilePatchValidator(jsonSchema);
         validators.patchValidator = validator;
       }
+    } else if (queryPropKeys) {
+      const key = JSON.stringify(queryPropKeys);
+      validators.queryPropValidators = validators.queryPropValidators || new Map();
+      validator = validators.queryPropValidators.get(key);
+
+      if (!validator) {
+        validator = this.compileQueryPropValidator(
+          jsonSchemaWithoutRequiredKeys(jsonSchema, queryPropKeys),
+        );
+        validators.queryPropValidators.set(key, validator);
+      }
     } else {
       validator = validators.normalValidator;
 
@@ -169,6 +194,29 @@ class AjvValidator extends Validator {
   compileNormalValidator(jsonSchema) {
     return this.ajv.compile(jsonSchema);
   }
+
+  compileQueryPropValidator(jsonSchema) {
+    // The schema is a modified copy that keeps the `$id`s of the original, so
+    // it's compiled on an instance that doesn't add compiled schemas by their
+    // `$id`. Otherwise ajv would throw because the ids already exist.
+    if (!this.ajvQueryProps) {
+      this.ajvQueryProps = new Ajv(
+        Object.assign(
+          {
+            useDefaults: true,
+          },
+          this.ajvOptions,
+          {
+            addUsedSchema: false,
+          },
+        ),
+      );
+
+      this.setupAjv(this.ajvQueryProps);
+    }
+
+    return this.ajvQueryProps.compile(jsonSchema);
+  }
 }
 
 function parseValidationError(errors, modelClass, options, ajvOptions) {
@@ -397,6 +445,30 @@ function objectHasDefaults(obj) {
   return false;
 }
 
+// Returns the keys of the query properties of `model` (`raw()`, `val()`,
+// `ref()`, subqueries...) that are required by the schema but missing from
+// `json`, sorted, or `null` if there are none. Query properties are split from
+// the json before validation, but they do provide a value for the property.
+function getMissingQueryPropKeys(model, json, jsonSchema) {
+  const required = jsonSchema.required;
+
+  if (!Array.isArray(required) || required.length === 0) {
+    return null;
+  }
+
+  const keys = getQueryPropKeys(model).filter(
+    (key) => required.includes(key) && !Object.prototype.hasOwnProperty.call(json, key),
+  );
+
+  return keys.length > 0 ? keys.sort() : null;
+}
+
+function jsonSchemaWithoutRequiredKeys(jsonSchema, keys) {
+  return Object.assign({}, jsonSchema, {
+    required: jsonSchema.required.filter((key) => !keys.includes(key)),
+  });
+}
+
 function jsonSchemaWithoutRequired(jsonSchema) {
   // `not` is intentionally left untouched: Stripping `required` inside it
   // would turn it into a schema that rejects everything (e.g.
@@ -436,11 +508,20 @@ function definitionsWithoutRequired(jsonSchema, prop) {
 function subSchemaWithoutRequired(jsonSchema, prop) {
   if (jsonSchema[prop]) {
     if (Array.isArray(jsonSchema[prop])) {
-      const schemaArray = jsonSchemaArrayWithoutRequired(jsonSchema[prop]);
-
-      if (schemaArray.length !== 0) {
+      const schemaArray = jsonSchema[prop].map(jsonSchemaWithoutRequired);
+      const nonEmptySchemaArray = schemaArray.filter(isNotEmptyObject);
+
+      // An `anyOf` or `oneOf` option that only consisted of `required` is
+      // empty once `required` is stripped, and an empty schema matches any
+      // patch, just like the stripped `required` keywords elsewhere. Drop the
+      // whole keyword then: requiring the patch to match one of the remaining
+      // options would reject valid patches, and with `oneOf` keeping the empty
+      // option would fail every patch that also matches another option.
+      if (prop !== 'allOf' && nonEmptySchemaArray.length !== schemaArray.length) {
+        return {};
+      } else if (nonEmptySchemaArray.length !== 0) {
         return {
-          [prop]: schemaArray,
+          [prop]: nonEmptySchemaArray,
         };
       } else {
         return {};
@@ -467,10 +548,6 @@ function subSchemaWithoutRequired(jsonSchema, prop) {
   }
 }
 
-function jsonSchemaArrayWithoutRequired(jsonSchemaArray) {
-  return jsonSchemaArray.map(jsonSchemaWithoutRequired).filter(isNotEmptyObject);
-}
-
 function isNotEmptyObject(obj) {
   return Object.keys(obj).length !== 0;
 }

package/lib/model/Model.js

@@ -839,11 +839,13 @@ function getColumnNameMappers(modelClass) {
 }
 
 function getIdRelationProperty(modelClass) {
-  const idColumn = asArray(modelClass.getIdColumn());
+  // `idColumn = null` means that the model has no primary key.
+  const idColumn = modelClass.getIdColumn() === null ? [] : asArray(modelClass.getIdColumn());
 
   return new RelationProperty(
     idColumn.map((idCol) => `${modelClass.getTableName()}.${idCol}`),
     () => modelClass,
+    { allowEmpty: true },
   );
 }
 

package/lib/model/modelId.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { assertHasIdColumn } = require('../utils/assert');
+
 function getSetId(model, maybeId) {
   if (maybeId !== undefined) {
     return setId(model, maybeId);
@@ -9,10 +11,13 @@ function getSetId(model, maybeId) {
 }
 
 function hasId(model) {
-  return model.$hasProps(model.constructor.getIdPropertyArray());
+  const idProps = model.constructor.getIdPropertyArray();
+  // Models without an `idColumn` never have an id.
+  return idProps.length > 0 && model.$hasProps(idProps);
 }
 
 function setId(model, id) {
+  assertHasIdColumn(model.constructor);
   const idProp = model.constructor.getIdProperty();
   const isCompositeId = Array.isArray(idProp);
 
@@ -49,7 +54,10 @@ function getId(model) {
   const idProp = model.constructor.getIdProperty();
   const isCompositeId = Array.isArray(idProp);
 
-  if (isCompositeId) {
+  if (isCompositeId && idProp.length === 0) {
+    // Models without an `idColumn` have no id.
+    return undefined;
+  } else if (isCompositeId) {
     return model.$values(idProp);
   } else {
     return model[idProp];

package/lib/model/modelQueryProps.js

@@ -108,6 +108,12 @@ function convertAndMergeHiddenQueryProps(model, json, omitProps, builder) {
   return json;
 }
 
+// Returns the keys of the query properties that were split from `model`.
+function getQueryPropKeys(model) {
+  const queryProps = model[QUERY_PROPS_PROPERTY];
+  return queryProps ? Object.keys(queryProps) : [];
+}
+
 // Converts a query property into a knex `raw` instance.
 function queryPropToKnexRaw(queryProp, builder) {
   if (!queryProp) {
@@ -144,4 +150,5 @@ function isKnexRawConvertable(queryProp) {
 module.exports = {
   splitQueryProps,
   mergeQueryProps,
+  getQueryPropKeys,
 };

package/lib/queryBuilder/QueryBuilder.js

@@ -1,13 +1,13 @@
 'use strict';
 
-const { wrapError } = require('db-errors');
+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 } = require('../utils/assert');
+const { assertIdNotUndefined, assertHasIdColumn } = require('../utils/assert');
 
 const { Selection } = require('./operations/select/Selection');
 
@@ -125,6 +125,8 @@ class QueryBuilder extends QueryBuilderBase {
   }
 
   fullIdColumnFor(modelClass) {
+    assertHasIdColumn(modelClass);
+
     const tableName = this.tableRefFor(modelClass);
     const idColumn = modelClass.getIdColumn();
 
@@ -1408,7 +1410,7 @@ function handleExecuteError(builder, err) {
     return Promise.resolve(err.value);
   }
 
-  let promise = Promise.reject(wrapError(err));
+  let promise = Promise.reject(wrapDbError(err));
 
   builder.forEachOperation(true, (op) => {
     if (op.hasOnError()) {

package/lib/queryBuilder/QueryBuilderBase.js

@@ -616,9 +616,14 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
   // whereJson(Not)SupersetOf / whereJson(Not)SubsetOf are now supported by knex >= 1.0, but for now
   // objection handles them differently and only for postgres.
   // Changing them to utilize knex methods directly may require a major version bump and upgrade guide.
+  // On MySQL, the simple `(column, object | array)` form is passed on to knex (ditojs#113).
   whereJsonSupersetOf(...args) {
     return this.addOperation(
-      new WhereJsonPostgresOperation('whereJsonSupersetOf', { operator: '@>', bool: 'and' }),
+      new WhereJsonPostgresOperation('whereJsonSupersetOf', {
+        operator: '@>',
+        bool: 'and',
+        knexMethod: 'whereJsonSupersetOf',
+      }),
       args,
     );
   }
@@ -629,7 +634,11 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
 
   orWhereJsonSupersetOf(...args) {
     return this.addOperation(
-      new WhereJsonPostgresOperation('orWhereJsonSupersetOf', { operator: '@>', bool: 'or' }),
+      new WhereJsonPostgresOperation('orWhereJsonSupersetOf', {
+        operator: '@>',
+        bool: 'or',
+        knexMethod: 'whereJsonSupersetOf',
+      }),
       args,
     );
   }
@@ -640,13 +649,14 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
         operator: '@>',
         bool: 'and',
         prefix: 'not',
+        knexMethod: 'whereJsonNotSupersetOf',
       }),
       args,
     );
   }
 
   andWhereJsonNotSupersetOf(...args) {
-    return this.andWhereJsonNotSupersetOf(...args);
+    return this.whereJsonNotSupersetOf(...args);
   }
 
   orWhereJsonNotSupersetOf(...args) {
@@ -655,6 +665,7 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
         operator: '@>',
         bool: 'or',
         prefix: 'not',
+        knexMethod: 'whereJsonNotSupersetOf',
       }),
       args,
     );
@@ -662,7 +673,11 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
 
   whereJsonSubsetOf(...args) {
     return this.addOperation(
-      new WhereJsonPostgresOperation('whereJsonSubsetOf', { operator: '<@', bool: 'and' }),
+      new WhereJsonPostgresOperation('whereJsonSubsetOf', {
+        operator: '<@',
+        bool: 'and',
+        knexMethod: 'whereJsonSubsetOf',
+      }),
       args,
     );
   }
@@ -673,7 +688,11 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
 
   orWhereJsonSubsetOf(...args) {
     return this.addOperation(
-      new WhereJsonPostgresOperation('orWhereJsonSubsetOf', { operator: '<@', bool: 'or' }),
+      new WhereJsonPostgresOperation('orWhereJsonSubsetOf', {
+        operator: '<@',
+        bool: 'or',
+        knexMethod: 'whereJsonSubsetOf',
+      }),
       args,
     );
   }
@@ -684,6 +703,7 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
         operator: '<@',
         bool: 'and',
         prefix: 'not',
+        knexMethod: 'whereJsonNotSubsetOf',
       }),
       args,
     );
@@ -699,6 +719,7 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
         operator: '<@',
         bool: 'or',
         prefix: 'not',
+        knexMethod: 'whereJsonNotSubsetOf',
       }),
       args,
     );
@@ -772,20 +793,34 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
     );
   }
 
+  // Not passed on to knex like `whereJsonSupersetOf()`, as MySQL's `json_contains()`
+  // also matches `{}` in arrays of objects.
   whereJsonIsArray(fieldExpression) {
-    return this.whereJsonSupersetOf(fieldExpression, []);
+    return this.addOperation(
+      new WhereJsonPostgresOperation('whereJsonSupersetOf', { operator: '@>', bool: 'and' }),
+      [fieldExpression, []],
+    );
   }
 
   orWhereJsonIsArray(fieldExpression) {
-    return this.orWhereJsonSupersetOf(fieldExpression, []);
+    return this.addOperation(
+      new WhereJsonPostgresOperation('orWhereJsonSupersetOf', { operator: '@>', bool: 'or' }),
+      [fieldExpression, []],
+    );
   }
 
   whereJsonIsObject(fieldExpression) {
-    return this.whereJsonSupersetOf(fieldExpression, {});
+    return this.addOperation(
+      new WhereJsonPostgresOperation('whereJsonSupersetOf', { operator: '@>', bool: 'and' }),
+      [fieldExpression, {}],
+    );
   }
 
   orWhereJsonIsObject(fieldExpression) {
-    return this.orWhereJsonSupersetOf(fieldExpression, {});
+    return this.addOperation(
+      new WhereJsonPostgresOperation('orWhereJsonSupersetOf', { operator: '@>', bool: 'or' }),
+      [fieldExpression, {}],
+    );
   }
 
   whereColumn(...args) {

package/lib/queryBuilder/ReferenceBuilder.js

@@ -5,6 +5,7 @@ const {
   toPostgresJsonPathLiteral,
 } = require('../utils/parseFieldExpression');
 const { isObject } = require('../utils/objectUtils');
+const { warnIfNotPostgres } = require('./operations/jsonApi/postgresJsonApi');
 
 class ReferenceBuilder {
   constructor(expr) {
@@ -163,7 +164,13 @@ class ReferenceBuilder {
   }
 
   toKnexRaw(builder) {
-    return builder.knex().raw(...this._createRawArgs(builder));
+    const knex = builder.knex();
+
+    if (this._parsedExpr.access.length > 0) {
+      warnIfNotPostgres(knex);
+    }
+
+    return knex.raw(...this._createRawArgs(builder));
   }
 
   _parseExpression(expr) {

package/lib/queryBuilder/graph/GraphFetcher.js

@@ -153,9 +153,7 @@ function createManyToManyExtraSelectionIfNeeded(builder, column, node) {
     const extra = relation.joinTableExtras.find((extra) => extra.aliasCol === column);
 
     if (extra) {
-      return `${builder.tableRefFor(relation.joinModelClass)}.${extra.joinTableCol} as ${
-        extra.aliasCol
-      }`;
+      return `${relation.joinTableAliasFor(builder)}.${extra.joinTableCol} as ${extra.aliasCol}`;
     }
   }
 

package/lib/queryBuilder/graph/GraphOptions.js

@@ -13,6 +13,20 @@ const INSERT_MISSING = 'insertMissing';
 const FETCH_STRATEGY = 'fetchStrategy';
 const ALLOW_REFS = 'allowRefs';
 
+const OPTION_NAMES = [
+  NO_RELATE,
+  NO_UNRELATE,
+  NO_INSERT,
+  NO_UPDATE,
+  NO_DELETE,
+  UPDATE,
+  RELATE,
+  UNRELATE,
+  INSERT_MISSING,
+  FETCH_STRATEGY,
+  ALLOW_REFS,
+];
+
 const FetchStrategy = {
   OnlyIdentifiers: 'OnlyIdentifiers',
   Everything: 'Everything',
@@ -64,7 +78,7 @@ class GraphOptions {
       !getCurrentNode(node, graphData) &&
       !!node.parentEdge &&
       !!node.parentEdge.relation &&
-      node.parentEdge.relation.hasRelateProp(node.obj) &&
+      hasRelateProp(node) &&
       graphData.nodeDbExistence.doesNodeExistInDb(node)
     );
   }
@@ -212,6 +226,20 @@ function getCurrentNode(node, graphData) {
   return graphData.currentGraph.nodeForNode(node);
 }
 
+// For `HasMany` and `HasOne` relations, the relate prop is the id of the
+// related model. Use the id state of the input graph, since the parent's
+// insert copies the foreign key into the related model, which can complete
+// a composite id that contains it and would turn an insert into a relate (#2544).
+function hasRelateProp(node) {
+  const relation = node.parentEdge.relation;
+
+  if (relation.isObjectionHasManyRelation) {
+    return node.hasId;
+  } else {
+    return relation.hasRelateProp(node.obj);
+  }
+}
+
 function getNode(currentNode, graph) {
   if (!graph || !currentNode) {
     return null;
@@ -222,5 +250,6 @@ function getNode(currentNode, graph) {
 
 module.exports = {
   GraphOptions,
+  OPTION_NAMES,
   FetchStrategy,
 };

package/lib/queryBuilder/graph/GraphUpsert.js

@@ -8,7 +8,7 @@ const { GraphInsert } = require('./insert/GraphInsert');
 const { GraphPatch } = require('./patch/GraphPatch');
 const { GraphDelete } = require('./delete/GraphDelete');
 const { GraphRecursiveUpsert } = require('./recursiveUpsert/GraphRecursiveUpsert');
-const { GraphOptions } = require('./GraphOptions');
+const { GraphOptions, OPTION_NAMES } = require('./GraphOptions');
 const { ValidationErrorType } = require('../../model/ValidationError');
 const { RelationExpression } = require('../RelationExpression');
 const { GraphNodeDbExistence } = require('./GraphNodeDbExistence');
@@ -19,6 +19,7 @@ const { deprecate } = require('../../utils/deprecate');
 class GraphUpsert {
   constructor({ rootModelClass, objects, upsertOptions }) {
     checkCanBeConvertedToModels(rootModelClass, objects);
+    warnOnUnknownOptions(upsertOptions);
 
     this.objects = rootModelClass.ensureModelArray(objects, GraphUpsert.modelOptions);
     this.isArray = Array.isArray(objects);
@@ -61,6 +62,20 @@ class GraphUpsert {
   }
 }
 
+// Misspelled options are silently ignored, so the operation runs with the
+// default behaviour instead (#84). A warning is logged once per option.
+// TODO: Throw an error instead in objection 4.0.
+function warnOnUnknownOptions(upsertOptions) {
+  for (const name of Object.keys(upsertOptions)) {
+    if (!OPTION_NAMES.includes(name)) {
+      deprecate(
+        `Unknown graph option "${name}" is ignored. ` +
+          `Valid options are: ${OPTION_NAMES.join(', ')}. This will throw in objection 4.0.`,
+      );
+    }
+  }
+}
+
 function checkCanBeConvertedToModels(modelClass, objects) {
   asArray(objects).forEach((obj) => {
     if (!isObject(obj)) {

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

@@ -3,7 +3,7 @@
 const { getModel } = require('../../../model/getModel');
 const { GraphAction } = require('../GraphAction');
 const { isInternalProp } = require('../../../utils/internalPropUtils');
-const { difference, isObject, jsonEquals } = require('../../../utils/objectUtils');
+const { difference, isObject, isPlainObject, jsonEquals } = require('../../../utils/objectUtils');
 const promiseUtils = require('../../../utils/promiseUtils');
 
 class GraphPatchAction extends GraphAction {
@@ -251,13 +251,19 @@ function childQueryOptions() {
 }
 
 function nonStrictEquals(val1, val2) {
-  if (val1 == val2) {
+  // Only use loose equality for non-JSON values, so that for example `false`
+  // and `[]` are not considered equal. See issue #1874.
+  if (!isJsonValue(val1) && !isJsonValue(val2) && val1 == val2) {
     return true;
   }
 
   return jsonEquals(val1, val2);
 }
 
+function isJsonValue(value) {
+  return Array.isArray(value) || isPlainObject(value);
+}
+
 function isToBeUnrelatedOrDeleted(node) {
   return !!node && node.toBeUnrelatedOrDeleted;
 }