objection 3.3.0 → 3.4.0

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/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;
 }

package/lib/queryBuilder/join/RelationJoiner.js

@@ -8,7 +8,7 @@ const { ValidationErrorType } = require('../../model/ValidationError');
 
 const { TableTree } = require('./TableTree');
 const { JoinResultParser } = require('./JoinResultParser');
-const { ID_LENGTH_LIMIT } = require('./utils');
+const { getIdentifierLengthLimit } = require('./utils');
 
 /**
  * Given a relation expression, builds a query using joins to fetch it.
@@ -179,8 +179,10 @@ class RelationJoiner {
       userSelectQueries,
     });
 
+    const lengthLimit = getIdentifierLengthLimit(builder.knex());
+
     for (const selection of selections) {
-      checkAliasLength(tableNode.modelClass, selection.name);
+      checkAliasLength(tableNode.modelClass, selection.name, lengthLimit);
     }
 
     // Save the selections that were added internally (not by the user)
@@ -393,11 +395,13 @@ function selectsOnlyAliasesKeepingSelectAll(selections) {
   return selections.length > 0 && selections.every((it) => it.keepsSelectAll);
 }
 
-function checkAliasLength(modelClass, alias) {
-  if (alias.length > ID_LENGTH_LIMIT) {
+function checkAliasLength(modelClass, alias, lengthLimit) {
+  if (alias.length > lengthLimit) {
     throw modelClass.createValidationError({
       type: ValidationErrorType.RelationExpression,
-      message: `identifier ${alias} is over ${ID_LENGTH_LIMIT} characters long and would be truncated by the database engine.`,
+      message:
+        `identifier ${alias} is over ${lengthLimit} characters long and would be truncated by the database engine. ` +
+        'Use the `minimize` option of withGraphJoined() to shorten the aliases.',
     });
   }
 }

package/lib/queryBuilder/join/utils.js

@@ -1,10 +1,27 @@
 'use strict';
 
 const { ValidationErrorType } = require('../../model/ValidationError');
+const { isPostgres, isMySql, isMsSql, isSqlite } = require('../../utils/knexUtils');
 
-const ID_LENGTH_LIMIT = 63;
 const RELATION_RECURSION_LIMIT = 64;
 
+// The maximum length of the column aliases of the joined relations, after
+// which the database would truncate them. Unknown databases use the strictest
+// of the known limits, the one of postgres.
+function getIdentifierLengthLimit(knex) {
+  if (isPostgres(knex)) {
+    return 63;
+  } else if (isMySql(knex)) {
+    return 256;
+  } else if (isMsSql(knex)) {
+    return 128;
+  } else if (isSqlite(knex)) {
+    return Infinity;
+  } else {
+    return 63;
+  }
+}
+
 // Given a relation expression, goes through all first level children.
 function forEachChildExpression(expr, modelClass, callback) {
   if (expr.node.$allRecursive || expr.maxRecursionDepth > RELATION_RECURSION_LIMIT) {
@@ -18,8 +35,9 @@ function forEachChildExpression(expr, modelClass, callback) {
 }
 
 module.exports = {
-  ID_LENGTH_LIMIT,
   RELATION_RECURSION_LIMIT,
 
+  getIdentifierLengthLimit,
+
   forEachChildExpression,
 };

package/lib/queryBuilder/operations/InsertOperation.js

@@ -38,18 +38,20 @@ class InsertOperation extends QueryBuilderOperation {
   onBuildKnex(knexBuilder, builder) {
     const knex = builder.knex();
 
-    if (!builder.has(/returning/)) {
+    const defaultReturning = getDefaultReturning(builder);
+
+    if (!builder.has(/returning/) && defaultReturning !== null) {
       if (!isSqlite(knex) && !isMySql(knex)) {
         // If the user hasn't specified a `returning` clause, we make sure
         // that at least the identifier is returned. With `onConflict()` the
         // conflict columns are returned too, so that the returned rows can
         // be matched to the models when some of the rows are ignored.
-        knexBuilder = knexBuilder.returning(getDefaultReturning(builder));
+        knexBuilder = knexBuilder.returning(defaultReturning);
       } else if (isSqlite(knex) && builder.has('onConflict')) {
         // Without a `returning` clause, SQLite returns the id of the last
         // inserted row, which belongs to a previous insert if the row was
         // ignored. Use `returning` to find out what was actually inserted.
-        knexBuilder = knexBuilder.returning(getDefaultReturning(builder));
+        knexBuilder = knexBuilder.returning(defaultReturning);
       }
     }
 
@@ -77,7 +79,7 @@ class InsertOperation extends QueryBuilderOperation {
           this.models[i].$setDatabaseJson(ret[i]);
         }
       }
-    } else {
+    } else if (builder.modelClass().getIdColumnArray().length > 0) {
       // If the return value is not an array of objects, we assume it is an array of identifiers.
       for (let i = 0, l = this.models.length; i < l; ++i) {
         const model = this.models[i];
@@ -113,10 +115,15 @@ class InsertOperation extends QueryBuilderOperation {
   }
 }
 
+// Returns `null` if there's nothing to return, e.g. for models without an `idColumn`.
 function getDefaultReturning(builder) {
   const idColumns = builder.modelClass().getIdColumnArray();
   const columns = Array.from(new Set(idColumns.concat(getConflictColumns(builder))));
 
+  if (columns.length === 0) {
+    return null;
+  }
+
   return columns.length === 1 ? columns[0] : columns;
 }
 

package/lib/relations/RelationFindOperation.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { FindOperation } = require('../queryBuilder/operations/FindOperation');
+const { deprecate } = require('../utils/deprecate');
 
 class RelationFindOperation extends FindOperation {
   constructor(name, opt) {
@@ -19,8 +20,12 @@ class RelationFindOperation extends FindOperation {
     this.maybeApplyAlias(builder);
     this.relation.findQuery(builder, this.owner);
 
-    if (this.assignResultToOwner && this.owner.isModels) {
-      this.selectMissingJoinColumns(builder);
+    if (this.owner.isModels) {
+      this.warnOnMissingOwnerProps();
+
+      if (this.assignResultToOwner) {
+        this.selectMissingJoinColumns(builder);
+      }
     }
   }
 
@@ -44,6 +49,8 @@ class RelationFindOperation extends FindOperation {
         arr.push(rel);
       }
 
+      this.warnOnMissingRelatedProps(related);
+
       for (let i = 0, l = owners.length; i < l; ++i) {
         const own = owners[i];
         const key = this.relation.ownerProp.propKey(own);
@@ -75,6 +82,43 @@ class RelationFindOperation extends FindOperation {
     return super.onAfter3(builder, related);
   }
 
+  // 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.
+  // TODO: Consider throwing an error instead in objection 4.0.
+  warnOnMissingOwnerProps() {
+    const { ownerProp } = this.relation;
+
+    for (let c = 0, lc = ownerProp.size; c < lc; ++c) {
+      if (this.owner.modelArray.some((owner) => ownerProp.getProp(owner, c) === undefined)) {
+        deprecate(
+          `Fetching relation "${this.relation.name}" of ${this.relation.ownerModelClass.name}: ` +
+            `some owner models are missing the join property "${ownerProp.propDescription(c)}", ` +
+            'so no related models are found for them. Select the column in the owner query.',
+        );
+      }
+    }
+  }
+
+  // Related models without the join properties can't be assigned to their
+  // owners and are silently dropped (#2258). This happens for example when the
+  // relation mapping uses column names but the rows come back with different
+  // property names, e.g. snake_case mappings with `knexSnakeCaseMappers`.
+  warnOnMissingRelatedProps(related) {
+    const { relatedProp } = this.relation;
+
+    for (let c = 0, lc = relatedProp.size; c < lc; ++c) {
+      if (related.some((rel) => relatedProp.getProp(rel, c) === undefined)) {
+        deprecate(
+          `Fetching relation "${this.relation.name}" of ${this.relation.ownerModelClass.name}: ` +
+            `some related models are missing the join property "${relatedProp.propDescription(c)}", ` +
+            'so they are not assigned to any owner. Check that the relation mapping uses the ' +
+            'property names of the models, e.g. camelCase names when using knexSnakeCaseMappers.',
+        );
+      }
+    }
+  }
+
   selectMissingJoinColumns(builder) {
     const relatedProp = this.relation.relatedProp;
     const addedSelects = [];

package/lib/relations/RelationProperty.js

@@ -31,10 +31,11 @@ class RelationProperty {
   //
   // modelClassResolver must be a function that takes a table name
   // and returns a model class.
-  constructor(references, modelClassResolver) {
+  constructor(references, modelClassResolver, { allowEmpty = false } = {}) {
     const refs = createRefs(asArray(references));
     const paths = createPaths(refs, modelClassResolver);
-    const modelClass = resolveModelClass(paths);
+    const modelClass =
+      allowEmpty && refs.length === 0 ? modelClassResolver(null) : resolveModelClass(paths);
 
     this._refs = refs.map((ref) => ref.model(modelClass));
     this._modelClass = modelClass;

package/lib/relations/manyToMany/ManyToManyRelation.js

@@ -75,10 +75,39 @@ class ManyToManyRelation extends Relation {
     return [];
   }
 
+  isJoinTableRelatedTable(builder) {
+    return builder.tableNameFor(this.joinTable) === builder.tableNameFor(this.relatedModelClass);
+  }
+
+  // Returns the alias of the join table in `findQuery`. If the join table is
+  // also the related table, it needs an alias of its own (#1803).
+  joinTableAliasFor(builder) {
+    const joinTableRef = builder.tableRefFor(this.joinTable);
+
+    if (this.isJoinTableRelatedTable(builder)) {
+      return this.ownerModelClass.joinTableAlias(joinTableRef);
+    } else {
+      return joinTableRef;
+    }
+  }
+
+  // The modify operations can't tell the join rows apart from the related rows
+  // if the join table is also the related table, so they would modify the
+  // wrong rows (#1803).
+  assertCanModifyJoinTable(builder, operationName) {
+    if (this.isJoinTableRelatedTable(builder)) {
+      throw this.createError(
+        `${operationName} is not supported when the join table is also the related table`,
+      );
+    }
+  }
+
   findQuery(builder, owner) {
-    const joinTableOwnerRefs = this.joinTableOwnerProp.refs(builder);
     const joinTable = builder.tableNameFor(this.joinTable);
-    const joinTableAlias = builder.tableRefFor(this.joinTable);
+    const joinTableAlias = this.joinTableAliasFor(builder);
+    const joinTableOwnerRefs = this.joinTableOwnerProp
+      .refs(builder)
+      .map((ref) => ref.table(joinTableAlias));
 
     let joinTableSelect = this.joinTableModelClass
       .query()
@@ -92,7 +121,7 @@ class ManyToManyRelation extends Relation {
     builder.join(joinTableSelect, (join) => {
       this.relatedProp.forEach((i) => {
         const relatedRef = this.relatedProp.ref(builder, i);
-        const joinTableRelatedRef = this.joinTableRelatedProp.ref(builder, i);
+        const joinTableRelatedRef = this.joinTableRelatedProp.ref(builder, i).table(joinTableAlias);
 
         join.on(relatedRef, joinTableRelatedRef);
       });
@@ -196,6 +225,8 @@ class ManyToManyRelation extends Relation {
   }
 
   unrelate(builder, owner) {
+    this.assertCanModifyJoinTable(builder, 'unrelate');
+
     return new (getUnrelateOperationClass(builder))('unrelate', {
       relation: this,
       owner,

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

@@ -29,7 +29,7 @@ class ManyToManyFindOperation extends RelationFindOperation {
 
       // Also select all extra columns.
       for (const extra of this.relation.joinTableExtras) {
-        const joinTable = builder.tableRefFor(this.relation.joinTable);
+        const joinTable = this.relation.joinTableAliasFor(builder);
         builder.select(`${joinTable}.${extra.joinTableCol} as ${extra.aliasCol}`);
       }
     }
@@ -88,7 +88,9 @@ class ManyToManyFindOperation extends RelationFindOperation {
     // We must select the owner join columns so that we know for which owner model the related
     // models belong to after the requests.
     joinTableOwnerProp.forEach((i) => {
-      const joinTableOwnerRef = joinTableOwnerProp.ref(builder, i);
+      const joinTableOwnerRef = joinTableOwnerProp
+        .ref(builder, i)
+        .table(this.relation.joinTableAliasFor(builder));
       const propName = relatedModelClass.columnNameToPropertyName(this.ownerJoinColumnAlias[i]);
 
       builder.select(joinTableOwnerRef.as(this.ownerJoinColumnAlias[i]));

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

@@ -26,6 +26,10 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
       }
     }
 
+    if (this.hasExtraProps) {
+      this.relation.assertCanModifyJoinTable(builder, `${this.name} with extra properties`);
+    }
+
     const res = super.onAdd(builder, args);
 
     if (this.hasExtraProps) {

package/lib/utils/assert.js

@@ -1,6 +1,14 @@
 'use strict';
 
+function assertHasIdColumn(modelClass) {
+  if (modelClass.getIdColumnArray().length === 0) {
+    throw new Error(`model ${modelClass.name} has no idColumn`);
+  }
+}
+
 function assertHasId(model) {
+  assertHasIdColumn(model.constructor);
+
   if (!model.$hasId()) {
     const modelClass = model.constructor;
     const ids = modelClass.getIdColumnArray().join(', ');
@@ -21,5 +29,6 @@ function assertIdNotUndefined(id, message) {
 
 module.exports = {
   assertHasId,
+  assertHasIdColumn,
   assertIdNotUndefined,
 };

package/lib/utils/wrapDbError.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const { wrapError, DBError, UniqueViolationError } = require('db-errors');
+
+// db-errors only recognizes mssql unique key violations, but the same error
+// number (2627) is also used for primary key violations (#2688).
+const MSSQL_PRIMARY_KEY_REGEX =
+  /Violation of PRIMARY KEY constraint '(.+)'\. Cannot insert duplicate key in object '(.+)\.(.+)'\. The duplicate key value is \((.+)\)/;
+
+function wrapDbError(err) {
+  const wrapped = wrapError(err);
+
+  if (wrapped.constructor === DBError && wrapped.client === 'mssql') {
+    const { nativeError } = wrapped;
+    const match =
+      nativeError.info &&
+      nativeError.info.number === 2627 &&
+      MSSQL_PRIMARY_KEY_REGEX.exec(nativeError.message);
+
+    if (match) {
+      return new UniqueViolationError({
+        nativeError,
+        client: 'mssql',
+        table: match[3],
+        schema: match[2],
+        constraint: match[1],
+      });
+    }
+  }
+
+  return wrapped;
+}
+
+module.exports = {
+  wrapDbError,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "objection",
-  "version": "3.3.0",
+  "version": "3.4.0",
   "description": "An SQL-friendly ORM for Node.js",
   "main": "lib/objection.js",
   "license": "MIT",
@@ -63,11 +63,10 @@
     "db-errors": "^0.2.3"
   },
   "peerDependencies": {
-    "knex": ">=1.0.1"
+    "knex": ">=2.3.0"
   },
   "devDependencies": {
     "@types/node": "^22.15.3",
-    "bluebird": "^3.7.2",
     "chai": "^4.3.10",
     "chai-subset": "^1.6.0",
     "eslint": "^8.54.0",
@@ -75,14 +74,12 @@
     "eslint-plugin-prettier": "^5.3.1",
     "expect.js": "^0.3.1",
     "knex": "^3.3.0",
-    "lodash": "^4.18.1",
     "mocha": "^11.2.2",
     "mysql": "^2.18.1",
     "pg": "^8.15.6",
     "prettier": "3.9.9",
     "sqlite3": "^5.1.7",
     "typescript": ">=5.8.3",
-    "uuid": "^9.0.1",
     "vitepress": "1.6.4"
   }
 }

package/typings/objection/index.d.ts

@@ -590,7 +590,7 @@ declare namespace Objection {
   }
 
   interface FromMethod<QB extends AnyQueryBuilder> {
-    (table: TableRef<QB>): QB;
+    (table: TableRef<QB>, options?: { only?: boolean }): QB;
   }
 
   interface FromRawMethod<QB extends AnyQueryBuilder> extends RawInterface<QB> {}