objection 3.2.0 → 3.4.0

package/README.md

@@ -3,7 +3,7 @@
 [![Tests](https://github.com/ditojs/objection/actions/workflows/test.yml/badge.svg)](https://github.com/ditojs/objection/actions)
 [![Join the chat at https://gitter.im/Vincit/objection.js](https://badges.gitter.im/Vincit/objection.js.svg)](https://gitter.im/Vincit/objection.js?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
-# [Objection.js](https://vincit.github.io/objection.js)
+# [Objection.js](https://ditojs.github.io/objection/)
 
 Objection.js is an [ORM](https://en.wikipedia.org/wiki/Object-relational_mapping) for [Node.js](https://nodejs.org/) that aims to stay out of your way and make it as easy as possible to use the full power of SQL and the underlying database engine while still making the common stuff easy and enjoyable.
 
@@ -13,13 +13,13 @@ Objection.js is built on an SQL query builder called [knex](http://knexjs.org).
 
 What objection.js gives you:
 
-- **An easy declarative way of [defining models](https://vincit.github.io/objection.js/guide/models.html) and relationships between them**
-- **Simple and fun way to [fetch, insert, update and delete](https://vincit.github.io/objection.js/guide/query-examples.html) objects using the full power of SQL**
-- **Powerful mechanisms for [eager loading](https://vincit.github.io/objection.js/guide/query-examples.html#eager-loading), [inserting](https://vincit.github.io/objection.js/guide/query-examples.html#graph-inserts) and [upserting](https://vincit.github.io/objection.js/guide/query-examples.html#graph-upserts) object graphs**
-- **Easy to use [transactions](https://vincit.github.io/objection.js/guide/transactions.html)**
+- **An easy declarative way of [defining models](https://ditojs.github.io/objection/guide/models.html) and relationships between them**
+- **Simple and fun way to [fetch, insert, update and delete](https://ditojs.github.io/objection/guide/query-examples.html) objects using the full power of SQL**
+- **Powerful mechanisms for [eager loading](https://ditojs.github.io/objection/guide/query-examples.html#eager-loading), [inserting](https://ditojs.github.io/objection/guide/query-examples.html#graph-inserts) and [upserting](https://ditojs.github.io/objection/guide/query-examples.html#graph-upserts) object graphs**
+- **Easy to use [transactions](https://ditojs.github.io/objection/guide/transactions.html)**
 - **Official [TypeScript](https://github.com/ditojs/objection/blob/main/typings/objection/index.d.ts) support**
-- **Optional [JSON schema](https://vincit.github.io/objection.js/guide/validation.html) validation**
-- **A way to [store complex documents](https://vincit.github.io/objection.js/guide/documents.html) as single rows**
+- **Optional [JSON schema](https://ditojs.github.io/objection/guide/validation.html) validation**
+- **A way to [store complex documents](https://ditojs.github.io/objection/guide/documents.html) as single rows**
 
 What objection.js **doesn't** give you:
 
@@ -31,7 +31,7 @@ What objection.js **doesn't** give you:
 - **A custom query DSL. SQL is used as a query language.**
   This doesn't mean you have to write SQL strings though. A query builder based on [knex](http://knexjs.org) is
   used to build the SQL. However, if the query builder fails you for some reason, raw SQL strings can be easily
-  written using the [raw](https://vincit.github.io/objection.js/api/objection/#raw) helper function.
+  written using the [raw](https://ditojs.github.io/objection/api/objection/#raw) helper function.
 - **Automatic database schema creation and migration from model definitions.**
   For simple things it is useful that the database schema is automatically generated from the model definitions,
   but usually just gets in your way when doing anything non-trivial. Objection.js leaves the schema related things
@@ -45,9 +45,9 @@ Check out [this issue](https://github.com/Vincit/objection.js/issues/1069) to se
 Shortcuts:
 
 - [Who uses objection.js](https://github.com/Vincit/objection.js/discussions/2464)
-- [API reference](https://vincit.github.io/objection.js/api/query-builder/)
+- [API reference](https://ditojs.github.io/objection/api/query-builder/)
 - [Example projects](https://github.com/Vincit/objection.js/tree/main/examples)
-- [Changelog](https://vincit.github.io/objection.js/release-notes/changelog.html)
-- [v1 -> v2 -> v3 migration guide](https://vincit.github.io/objection.js/release-notes/migration.html)
-- [Contribution guide](https://vincit.github.io/objection.js/guide/contributing.html)
-- [Plugins](https://vincit.github.io/objection.js/guide/plugins.html)
+- [Changelog](https://ditojs.github.io/objection/release-notes/changelog.html)
+- [v1 -> v2 -> v3 migration guide](https://ditojs.github.io/objection/release-notes/migration.html)
+- [Contribution guide](https://ditojs.github.io/objection/guide/contributing.html)
+- [Plugins](https://ditojs.github.io/objection/guide/plugins.html)

package/lib/model/AjvValidator.js

@@ -5,6 +5,8 @@ const addFormats = require('ajv-formats');
 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) {
@@ -50,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 }) {
@@ -74,24 +80,40 @@ 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)) {
       json = cloneDeep(json);
     }
 
-    validator.call(model, json);
+    // Patch objects can contain field expression keys like `'meta:b'` that update
+    // a single property inside a json column. Validate them against the nested
+    // schema by converting them into nested objects like `{ meta: { b: value } }`.
+    const fieldExpressions = options.patch ? nestFieldExpressions(json) : null;
+    const validationJson = fieldExpressions ? fieldExpressions.json : json;
+
+    validator.call(model, validationJson);
     const error = parseValidationError(validator.errors, modelClass, options, this.ajvOptions);
 
     if (error) {
       throw error;
     }
 
+    if (fieldExpressions) {
+      // Copy back the changes made by Ajv options like `coerceTypes` and `removeAdditional`.
+      unnestFieldExpressions(json, fieldExpressions);
+    }
+
     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;
 
@@ -124,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);
@@ -136,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;
 
@@ -157,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) {
@@ -223,6 +283,116 @@ function parseValidationError(errors, modelClass, options, ajvOptions) {
   });
 }
 
+function nestFieldExpressions(json) {
+  const keys = Object.keys(json);
+
+  if (!keys.some(isFieldExpression)) {
+    return null;
+  }
+
+  const nested = Object.create(null);
+  const paths = new Map();
+  // The objects created here for the nested paths. Other objects are values
+  // of the input json and must not be modified.
+  const createdObjects = new Set();
+
+  for (const key of keys) {
+    if (!isFieldExpression(key)) {
+      nested[key] = json[key];
+      paths.set(key, [key]);
+    }
+  }
+
+  for (const key of keys) {
+    if (isFieldExpression(key)) {
+      const path = fieldExpressionPath(key);
+
+      // Field expressions with array access, and those that conflict with other
+      // keys of the patch, can't be validated without the current value of the
+      // json column. Leave them out of the validation.
+      if (path && setPath(nested, path, json[key], createdObjects)) {
+        paths.set(key, path);
+      }
+    }
+  }
+
+  return { json: nested, paths };
+}
+
+function unnestFieldExpressions(json, { json: nested, paths }) {
+  for (const [key, path] of paths) {
+    let value = nested;
+    let found = true;
+
+    for (const prop of path) {
+      found = isObject(value) && hasOwn(value, prop);
+
+      if (!found) {
+        break;
+      }
+
+      value = value[prop];
+    }
+
+    if (!found) {
+      // Removed by `removeAdditional`.
+      delete json[key];
+    } else if (json[key] !== value) {
+      json[key] = value;
+    }
+  }
+}
+
+function isFieldExpression(key) {
+  return key.indexOf(':') !== -1;
+}
+
+function fieldExpressionPath(key) {
+  let parsed;
+
+  try {
+    parsed = parseFieldExpression(key);
+  } catch (err) {
+    // Not a valid field expression, validate it as a top-level property.
+    return [key];
+  }
+
+  if (parsed.access.some((access) => access.type !== 'object')) {
+    return null;
+  }
+
+  return [parsed.column, ...parsed.access.map((access) => String(access.ref))];
+}
+
+function setPath(obj, path, value, createdObjects) {
+  const last = path.length - 1;
+
+  for (let i = 0; i < last; ++i) {
+    const prop = path[i];
+
+    if (!hasOwn(obj, prop)) {
+      const child = Object.create(null);
+      createdObjects.add(child);
+      obj[prop] = child;
+    } else if (!createdObjects.has(obj[prop])) {
+      return false;
+    }
+
+    obj = obj[prop];
+  }
+
+  if (hasOwn(obj, path[last])) {
+    return false;
+  }
+
+  obj[path[last]] = value;
+  return true;
+}
+
+function hasOwn(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
 function cloneDeep(obj) {
   if (isObject(obj) && obj.$isObjectionModel) {
     return obj.$clone();
@@ -275,8 +445,37 @@ 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) {
-  const subSchemaProps = ['anyOf', 'oneOf', 'allOf', 'not', 'then', 'else', 'properties'];
+  // `not` is intentionally left untouched: Stripping `required` inside it
+  // would turn it into a schema that rejects everything (e.g.
+  // `not: { required: ['a'] }` -> `not: {}`). Kept as is, it still holds for
+  // patches: Any property present in the patch is also present in the
+  // resulting object.
+  const subSchemaProps = ['anyOf', 'oneOf', 'allOf', 'then', 'else', 'properties'];
   // `definitions` was renamed to `$defs` in draft 2019-09. Support both.
   const definitionProps = ['definitions', '$defs'];
   return Object.assign(
@@ -309,16 +508,28 @@ 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 {};
       }
-    } else if (jsonSchema.type === 'object' && prop === 'properties') {
+    } else if (prop === 'properties') {
+      // `properties` is a map of property names to schemas, regardless of the
+      // schema's `type` (which may also be e.g. `['object', 'null']`, or be
+      // missing entirely).
       return {
         [prop]: Object.fromEntries(
           Object.entries(jsonSchema[prop]).map(([key, schema]) => [
@@ -337,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,
 };