objection 3.9.0 → 4.0.0-rc.1

package/lib/model/modelBindKnex.js

@@ -1,10 +1,8 @@
-'use strict';
+import { inheritModel } from './inheritModel.js';
+import { staticHiddenProps } from './modelUtils.js';
+import { defineNonEnumerableProperty } from './modelUtils.js';
 
-const { inheritModel } = require('./inheritModel');
-const { staticHiddenProps } = require('./modelUtils');
-const { defineNonEnumerableProperty } = require('./modelUtils');
-
-function bindKnex(modelClass, knex) {
+export function bindKnex(modelClass, knex) {
   let BoundModelClass = getBoundModelFromCache(modelClass, knex);
 
   if (BoundModelClass === null) {
@@ -77,7 +75,3 @@ function bindRelations(modelClass, BoundModelClass, knex) {
 
   return BoundModelClass;
 }
-
-module.exports = {
-  bindKnex,
-};

package/lib/model/modelClone.js

@@ -1,11 +1,9 @@
-'use strict';
+import { isObject, cloneDeep } from '../utils/objectUtils.js';
+import { hiddenProps } from './modelUtils.js';
+import { defineNonEnumerableProperty } from './modelUtils.js';
+import { isInternalProp } from '../utils/internalPropUtils.js';
 
-const { isObject, cloneDeep } = require('../utils/objectUtils');
-const { hiddenProps } = require('./modelUtils');
-const { defineNonEnumerableProperty } = require('./modelUtils');
-const { isInternalProp } = require('../utils/internalPropUtils');
-
-function clone(model, shallow, stripInternal) {
+export function clone(model, shallow, stripInternal) {
   let clone = null;
 
   const omitFromJson = model.$omitFromJson();
@@ -113,7 +111,3 @@ function copyHiddenProps(model, clone) {
 
   return clone;
 }
-
-module.exports = {
-  clone,
-};

package/lib/model/modelColPropMap.js

@@ -1,8 +1,6 @@
-'use strict';
+import { difference } from '../utils/objectUtils.js';
 
-const { difference } = require('../utils/objectUtils');
-
-function columnNameToPropertyName(modelClass, columnName) {
+export function columnNameToPropertyName(modelClass, columnName) {
   const model = new modelClass();
   const addedProps = Object.keys(model.$parseDatabaseJson({}));
 
@@ -15,7 +13,7 @@ function columnNameToPropertyName(modelClass, columnName) {
   return propertyName || columnName;
 }
 
-function propertyNameToColumnName(modelClass, propertyName) {
+export function propertyNameToColumnName(modelClass, propertyName) {
   const model = new modelClass();
   const addedCols = Object.keys(model.$formatDatabaseJson({}));
 
@@ -27,8 +25,3 @@ function propertyNameToColumnName(modelClass, propertyName) {
 
   return columnName || propertyName;
 }
-
-module.exports = {
-  columnNameToPropertyName,
-  propertyNameToColumnName,
-};

package/lib/model/modelId.js

@@ -1,8 +1,6 @@
-'use strict';
+import { assertHasIdColumn } from '../utils/assert.js';
 
-const { assertHasIdColumn } = require('../utils/assert');
-
-function getSetId(model, maybeId) {
+export function getSetId(model, maybeId) {
   if (maybeId !== undefined) {
     return setId(model, maybeId);
   } else {
@@ -10,7 +8,7 @@ function getSetId(model, maybeId) {
   }
 }
 
-function hasId(model) {
+export function hasId(model) {
   const idProps = model.constructor.getIdPropertyArray();
   // Models without an `idColumn` never have an id.
   return idProps.length > 0 && model.$hasProps(idProps);
@@ -63,8 +61,3 @@ function getId(model) {
     return model[idProp];
   }
 }
-
-module.exports = {
-  getSetId,
-  hasId,
-};

package/lib/model/modelJsonAttributes.js

@@ -1,12 +1,12 @@
-'use strict';
+import { asArray, isObject, flatten, isString } from '../utils/objectUtils.js';
+import { isQueryProp } from './modelQueryProps.js';
+import { isJsonParsedByDriver } from '../utils/knexUtils.js';
 
-const { asArray, isObject, flatten, isString } = require('../utils/objectUtils');
-const { isQueryProp } = require('./modelQueryProps');
-
-function parseJsonAttributes(json, modelClass) {
+export function parseJsonAttributes(json, modelClass, knex) {
   const jsonAttr = modelClass.getJsonAttributes();
+  const format = getJsonColumnFormat(modelClass, knex);
 
-  if (jsonAttr.length) {
+  if (jsonAttr.length && format !== 'parsed') {
     // JSON attributes may be returned as strings depending on the database and
     // the database client. Convert them to objects here.
     for (let i = 0, l = jsonAttr.length; i < l; ++i) {
@@ -14,7 +14,7 @@ function parseJsonAttributes(json, modelClass) {
       const value = json[attr];
 
       if (isString(value)) {
-        const parsed = tryParseJson(value);
+        const parsed = format === 'text' ? parseJson(value, attr, modelClass) : tryParseJson(value);
 
         // tryParseJson returns undefined if parsing failed.
         if (parsed !== undefined) {
@@ -27,7 +27,7 @@ function parseJsonAttributes(json, modelClass) {
   return json;
 }
 
-function formatJsonAttributes(json, modelClass) {
+export function formatJsonAttributes(json, modelClass) {
   const jsonAttr = modelClass.getJsonAttributes();
 
   if (jsonAttr.length) {
@@ -46,7 +46,7 @@ function formatJsonAttributes(json, modelClass) {
   return json;
 }
 
-function getJsonAttributes(modelClass) {
+export function getJsonAttributes(modelClass) {
   let jsonAttributes = modelClass.jsonAttributes;
 
   if (Array.isArray(jsonAttributes)) {
@@ -85,6 +85,32 @@ function getPropertyTypes(prop) {
   return types;
 }
 
+// Resolve 'auto' to 'parsed' for drivers that return JSON columns parsed, or
+// else to `null`: JSON attributes may be text then, and are parsed leniently.
+function getJsonColumnFormat(modelClass, knex) {
+  const { jsonColumnFormat } = modelClass;
+
+  if (jsonColumnFormat === 'auto') {
+    return knex && isJsonParsedByDriver(knex) ? 'parsed' : null;
+  } else if (jsonColumnFormat === 'text' || jsonColumnFormat === 'parsed') {
+    return jsonColumnFormat;
+  } else {
+    throw new Error(
+      `Invalid jsonColumnFormat of model '${modelClass.name}': '${jsonColumnFormat}'.`,
+    );
+  }
+}
+
+function parseJson(str, attr, modelClass) {
+  try {
+    return JSON.parse(str);
+  } catch (err) {
+    throw new Error(
+      `Invalid JSON in JSON attribute '${attr}' of model '${modelClass.name}': ${err.message}`,
+    );
+  }
+}
+
 function tryParseJson(maybeJsonStr) {
   try {
     return JSON.parse(maybeJsonStr);
@@ -92,10 +118,3 @@ function tryParseJson(maybeJsonStr) {
     return undefined;
   }
 }
-
-module.exports = {
-  parseJsonAttributes,
-  formatJsonAttributes,
-  getJsonAttributes,
-  getPropertyTypes,
-};

package/lib/model/modelParseRelations.js

@@ -1,8 +1,6 @@
-'use strict';
+import { isObject } from '../utils/objectUtils.js';
 
-const { isObject } = require('../utils/objectUtils');
-
-function parseRelationsIntoModelInstances(model, json, options = {}) {
+export function parseRelationsIntoModelInstances(model, json, options = {}) {
   if (!options.cache) {
     options = Object.assign({}, options, {
       cache: new Map(),
@@ -76,7 +74,3 @@ function parseRelationObject(json, relation, options) {
     return json;
   }
 }
-
-module.exports = {
-  parseRelationsIntoModelInstances,
-};

package/lib/model/modelQueryProps.js

@@ -1,29 +1,41 @@
-'use strict';
-
-const { isObject, isFunction, omit } = require('../utils/objectUtils');
-const { defineNonEnumerableProperty } = require('./modelUtils');
-const { isKnexRaw, isKnexQueryBuilder } = require('../utils/knexUtils');
-const { parseFieldExpression, isFieldExpressionKey } = require('../utils/parseFieldExpression');
+import { isObject, isFunction, omit } from '../utils/objectUtils.js';
+import { defineNonEnumerableProperty } from './modelUtils.js';
+import { isKnexRaw, isKnexQueryBuilder } from '../utils/knexUtils.js';
+import { getFieldExpressionColumn } from '../utils/parseFieldExpression.js';
 
 const QUERY_PROPS_PROPERTY = '$$queryProps';
+// The keys of the field expression query properties like `'data:a'` that were
+// given while their json column `data` had a value:
+const COMBINED_QUERY_PROPS_PROPERTY = '$$combinedQueryProps';
 
 // Moves the query properties of `json` into a hidden property of `model` so
 // that they can be later merged back to its database json. A key holds either
 // a value or a query property, so the keys given in `json` replace the ones
 // that the model holds as the other kind.
-function splitQueryProps(model, json) {
+export function splitQueryProps(model, json) {
   const keys = Object.keys(json);
   const oldQueryProps = model[QUERY_PROPS_PROPERTY];
 
   if (!json.$isObjectionModel && hasQueryProps(json, keys)) {
     const queryProps = Object.assign({}, oldQueryProps);
+    const combinedKeys = new Set(model[COMBINED_QUERY_PROPS_PROPERTY]);
     const modelProps = {};
+    const jsonSchema = model.constructor.getJsonSchema();
+    const properties = jsonSchema && jsonSchema.properties;
 
     for (let i = 0, l = keys.length; i < l; ++i) {
       const key = keys[i];
       const value = json[key];
 
       if (isQueryProp(value)) {
+        const column = getFieldExpressionColumn(key, properties);
+
+        if (column !== null && (json[column] !== undefined || model[column] !== undefined)) {
+          combinedKeys.add(key);
+        } else {
+          combinedKeys.delete(key);
+        }
+
         queryProps[key] = value;
         delete model[key];
       } else {
@@ -33,6 +45,7 @@ function splitQueryProps(model, json) {
     }
 
     defineNonEnumerableProperty(model, QUERY_PROPS_PROPERTY, queryProps);
+    defineNonEnumerableProperty(model, COMBINED_QUERY_PROPS_PROPERTY, [...combinedKeys]);
 
     return modelProps;
   } else {
@@ -46,7 +59,7 @@ function splitQueryProps(model, json) {
 
 // Omits the values that parsing and validation add to `json` for the keys that
 // `model` holds query properties for, like Ajv defaults.
-function omitQueryProps(model, json) {
+export function omitQueryProps(model, json) {
   const keys = getQueryPropKeys(model);
   return keys.length > 0 ? omit(json, keys) : json;
 }
@@ -55,19 +68,22 @@ function omitQueryProps(model, json) {
 // assignment, `$set()` or a write that fetched the value from the database. We
 // do this when the model is passed to a write, and not when its database json
 // is built, so that the values set by its hooks don't override them.
-function removeOverriddenQueryProps(model) {
+export function removeOverriddenQueryProps(model) {
   const queryProps = model[QUERY_PROPS_PROPERTY];
 
   if (queryProps) {
     const jsonSchema = model.constructor.getJsonSchema();
     const properties = jsonSchema && jsonSchema.properties;
-    // The json column of a field expression key like `data:a` overrides it too:
-    const keys = Object.keys(queryProps).filter(
-      (key) =>
+    const combinedKeys = model[COMBINED_QUERY_PROPS_PROPERTY] || [];
+    const keys = Object.keys(queryProps).filter((key) => {
+      const column = getFieldExpressionColumn(key, properties);
+      return (
         model[key] !== undefined ||
-        (isFieldExpressionKey(key, properties) &&
-          model[parseFieldExpression(key).column] !== undefined),
-    );
+        // The json column of a field expression key like `data:a` overrides it
+        // too, unless it was given while the column had a value (#206):
+        (column !== null && !combinedKeys.includes(key) && model[column] !== undefined)
+      );
+    });
 
     if (keys.length > 0) {
       defineNonEnumerableProperty(model, QUERY_PROPS_PROPERTY, omit(queryProps, keys));
@@ -75,6 +91,15 @@ function removeOverriddenQueryProps(model) {
   }
 }
 
+// Removes the values that the hooks of a write set for the keys that `model`
+// holds query properties for. The query properties are written instead, so the
+// values must not count as given in later writes.
+export function removeOverriddenValues(model) {
+  for (const key of getQueryPropKeys(model)) {
+    delete model[key];
+  }
+}
+
 function hasQueryProps(json, keys) {
   for (let i = 0, l = keys.length; i < l; ++i) {
     if (isQueryProp(json[keys[i]])) {
@@ -85,7 +110,7 @@ function hasQueryProps(json, keys) {
   return false;
 }
 
-function isQueryProp(value) {
+export function isQueryProp(value) {
   if (!isObject(value)) {
     return false;
   }
@@ -99,7 +124,7 @@ function isQueryProp(value) {
 }
 
 // Merges and converts `model`'s query properties into `json`.
-function mergeQueryProps(model, json, omitProps, builder) {
+export function mergeQueryProps(model, json, omitProps, builder) {
   json = convertExistingQueryProps(json, builder);
   json = convertAndMergeHiddenQueryProps(model, json, omitProps, builder);
 
@@ -150,7 +175,7 @@ function convertAndMergeHiddenQueryProps(model, json, omitProps, builder) {
 }
 
 // Returns the keys of the query properties that were split from `model`.
-function getQueryPropKeys(model) {
+export function getQueryPropKeys(model) {
   const queryProps = model[QUERY_PROPS_PROPERTY];
   return queryProps ? Object.keys(queryProps) : [];
 }
@@ -187,12 +212,3 @@ function buildKnexRawConvertable(convertable, builder) {
 function isKnexRawConvertable(queryProp) {
   return isFunction(queryProp.toKnexRaw);
 }
-
-module.exports = {
-  splitQueryProps,
-  omitQueryProps,
-  removeOverriddenQueryProps,
-  mergeQueryProps,
-  getQueryPropKeys,
-  isQueryProp,
-};

package/lib/model/modelSet.js

@@ -1,11 +1,9 @@
-'use strict';
+import { isInternalProp } from '../utils/internalPropUtils.js';
+import { splitQueryProps, omitQueryProps } from './modelQueryProps.js';
+import { asArray, isFunction, isString, isPlainObject } from '../utils/objectUtils.js';
+import { parseRelationsIntoModelInstances } from './modelParseRelations.js';
 
-const { isInternalProp } = require('../utils/internalPropUtils');
-const { splitQueryProps, omitQueryProps } = require('./modelQueryProps');
-const { isFunction, isString, isPlainObject } = require('../utils/objectUtils');
-const { parseRelationsIntoModelInstances } = require('./modelParseRelations');
-
-function setJson(model, json, options) {
+export function setJson(model, json, options) {
   json = json || {};
   options = options || {};
 
@@ -34,8 +32,8 @@ function setJson(model, json, options) {
   return model;
 }
 
-function setDatabaseJson(model, json) {
-  json = model.$parseDatabaseJson(json);
+export function setDatabaseJson(model, json, options) {
+  json = model.$parseDatabaseJson(json, options);
 
   if (json) {
     const keys = Object.keys(json);
@@ -49,7 +47,7 @@ function setDatabaseJson(model, json) {
   return model;
 }
 
-function setFast(model, obj) {
+export function setFast(model, obj) {
   if (obj) {
     // Don't try to set read-only properties. They can easily get here
     // through `fromJson` when parsing an object that was previously
@@ -75,16 +73,39 @@ function setFast(model, obj) {
   return model;
 }
 
-function setRelated(model, relation, models) {
+export function setRelated(model, relation, models) {
+  relation = ensureRelation(model, relation);
+  const previous = model[relation.name];
+  assignRelated(model, relation, models);
+  syncForeignKeys(model, relation, model[relation.name], { previous });
+  return model;
+}
+
+export function appendRelated(model, relation, models) {
   relation = ensureRelation(model, relation);
 
   if (relation.isOneToOne()) {
+    return model.$setRelated(relation, models);
+  } else {
+    assignRelated(model, relation, models, { append: true });
+    syncForeignKeys(model, relation, models, { append: true });
+  }
+
+  return model;
+}
+
+// Assigns related models without syncing foreign keys, for the relation queries
+// that set the keys themselves:
+export function assignRelated(model, relation, models, { append = false } = {}) {
+  if (append && model[relation.name] && !relation.isOneToOne()) {
     if (Array.isArray(models)) {
-      if (models.length === 0) {
-        model[relation.name] = null;
-      } else {
-        model[relation.name] = models[0] || null;
-      }
+      models.forEach((it) => model[relation.name].push(it));
+    } else if (models) {
+      model[relation.name].push(models);
+    }
+  } else if (relation.isOneToOne()) {
+    if (Array.isArray(models)) {
+      model[relation.name] = models[0] || null;
     } else {
       model[relation.name] = models || null;
     }
@@ -97,24 +118,6 @@ function setRelated(model, relation, models) {
       model[relation.name] = [models];
     }
   }
-
-  return model;
-}
-
-function appendRelated(model, relation, models) {
-  relation = ensureRelation(model, relation);
-
-  if (!model[relation.name] || relation.isOneToOne()) {
-    return model.$setRelated(relation, models);
-  } else {
-    if (Array.isArray(models)) {
-      models.forEach((it) => model[relation.name].push(it));
-    } else if (models) {
-      model[relation.name].push(models);
-    }
-  }
-
-  return model;
 }
 
 function ensureRelation(model, relation) {
@@ -125,10 +128,55 @@ function ensureRelation(model, relation) {
   }
 }
 
-module.exports = {
-  setFast,
-  setJson,
-  setDatabaseJson,
-  setRelated,
-  appendRelated,
-};
+// Let the foreign keys follow the relation: a `BelongsToOneRelation` points the
+// owner to the related model, a `BelongsToManyRelation` to the related models,
+// `HasOneRelation` and `HasManyRelation` point the related models to the owner,
+// and the models that leave them to nothing. The keys of `ManyToManyRelation`
+// and `HasOneThroughRelation` live in the join table.
+function syncForeignKeys(model, relation, related, { previous = null, append = false } = {}) {
+  const { ownerProp, relatedProp } = relation;
+
+  if (relation.isObjectionBelongsToOneRelation) {
+    copyKey(relatedProp, related, ownerProp, model);
+  } else if (relation.isObjectionBelongsToManyRelation) {
+    // Models without a key are left out of the array:
+    const keys = asModels(related).map((it) => relatedProp.getProp(it, 0));
+
+    ownerProp.setProp(
+      model,
+      0,
+      relation.changeKeys(append ? relation.getKeys(model) : [], { add: keys }),
+    );
+  } else if (relation.isObjectionHasManyRelation) {
+    const models = asModels(related);
+
+    for (const it of models) {
+      copyKey(ownerProp, model, relatedProp, it);
+    }
+
+    if (ownerProp.hasProps(model)) {
+      const key = ownerProp.propKey(model);
+
+      for (const it of asModels(previous)) {
+        // Only clear the keys that still point to the owner, not the keys of
+        // models that moved to another owner in the meantime:
+        if (!models.includes(it) && relatedProp.propKey(it) === key) {
+          copyKey(ownerProp, null, relatedProp, it);
+        }
+      }
+    }
+  }
+}
+
+// Copies the key of `source` to `target`, or clears it if there's none to copy:
+function copyKey(sourceProp, source, targetProp, target) {
+  const hasKey = !!source && sourceProp.hasProps(source);
+
+  targetProp.forEach((i) => {
+    targetProp.setProp(target, i, hasKey ? sourceProp.getProp(source, i) : null);
+  });
+}
+
+function asModels(value) {
+  return asArray(value).filter(Boolean);
+}

package/lib/model/modelTableMetadata.js

@@ -1,11 +1,9 @@
-'use strict';
-
-const { defineNonEnumerableProperty } = require('./modelUtils');
-const { isPromise } = require('../utils/promiseUtils');
+import { defineNonEnumerableProperty } from './modelUtils.js';
+import { isPromise } from '../utils/promiseUtils/index.js';
 
 const TABLE_METADATA = '$$tableMetadata';
 
-function fetchTableMetadata(
+export function fetchTableMetadata(
   modelClass,
   { parentBuilder = null, knex = null, force = false, table = null } = {},
 ) {
@@ -63,7 +61,7 @@ function fetchTableMetadata(
   }
 }
 
-function tableMetadata(modelClass, { table } = {}) {
+export function tableMetadata(modelClass, { table } = {}) {
   if (modelClass.hasOwnProperty(TABLE_METADATA)) {
     const metadata = modelClass[TABLE_METADATA].get(table || modelClass.getTableName());
 
@@ -76,8 +74,3 @@ function tableMetadata(modelClass, { table } = {}) {
     return null;
   }
 }
-
-module.exports = {
-  fetchTableMetadata,
-  tableMetadata,
-};

package/lib/model/modelToJson.js

@@ -1,12 +1,10 @@
-'use strict';
-
-const { isInternalProp } = require('../utils/internalPropUtils');
-const { mergeQueryProps } = require('./modelQueryProps');
-const { isObject, hasOwn, cloneDeep, isFunction } = require('../utils/objectUtils');
-const { parseFieldExpression, isFieldExpressionKey } = require('../utils/parseFieldExpression');
+import { isInternalProp } from '../utils/internalPropUtils.js';
+import { mergeQueryProps } from './modelQueryProps.js';
+import { isObject, hasOwn, cloneDeep, isFunction } from '../utils/objectUtils.js';
+import { getFieldExpressionColumn } from '../utils/parseFieldExpression.js';
 const EMPTY_ARRAY = [];
 
-function toJson(model, optIn) {
+export function toJson(model, optIn) {
   const modelClass = model.constructor;
 
   const opt = {
@@ -25,7 +23,7 @@ function toJson(model, optIn) {
   return json;
 }
 
-function toDatabaseJson(model, builder) {
+export function toDatabaseJson(model, builder) {
   const modelClass = model.constructor;
 
   const opt = {
@@ -140,16 +138,8 @@ function shouldPick(opt, key) {
 
 // Pick field expressions like `'meta:a'` by their json column.
 function isPickedFieldExpression(pick, key) {
-  if (isFieldExpressionKey(key, pick)) {
-    try {
-      return hasOwn(pick, parseFieldExpression(key).column);
-    } catch (err) {
-      // Not a valid field expression.
-      return false;
-    }
-  } else {
-    return false;
-  }
+  const column = getFieldExpressionColumn(key, pick);
+  return column !== null && hasOwn(pick, column);
 }
 
 function assignVirtualAttributes(json, model, vAttr, opt) {
@@ -196,8 +186,3 @@ function toJsonArray(value, opt) {
 
   return ret;
 }
-
-module.exports = {
-  toJson,
-  toDatabaseJson,
-};

package/lib/model/modelUtils.js

@@ -1,8 +1,6 @@
-'use strict';
+export const hiddenProps = ['$$queryProps', '$$combinedQueryProps', '$$isFromDatabase'];
 
-const hiddenProps = ['$$queryProps'];
-
-const staticHiddenProps = [
+export const staticHiddenProps = [
   '$$knex',
   '$$validator',
   '$$jsonSchema',
@@ -19,7 +17,7 @@ const staticHiddenProps = [
   '$$virtualAttributes',
 ];
 
-function defineNonEnumerableProperty(obj, prop, value) {
+export function defineNonEnumerableProperty(obj, prop, value) {
   Object.defineProperty(obj, prop, {
     enumerable: false,
     writable: true,
@@ -28,7 +26,17 @@ function defineNonEnumerableProperty(obj, prop, value) {
   });
 }
 
-function keyByProps(models, props) {
+// Give `model` back the props that it left out of its database JSON, as
+// returned by `$omitFromDatabaseJson()` before more were left out.
+export function restoreOmitFromDatabaseJson(model, props) {
+  if (props) {
+    defineNonEnumerableProperty(model, '$$omitFromDatabaseJson', props);
+  } else {
+    delete model.$$omitFromDatabaseJson;
+  }
+}
+
+export function keyByProps(models, props) {
   const map = new Map();
 
   for (let i = 0, l = models.length; i < l; ++i) {
@@ -38,10 +46,3 @@ function keyByProps(models, props) {
 
   return map;
 }
-
-module.exports = {
-  hiddenProps,
-  staticHiddenProps,
-  defineNonEnumerableProperty,
-  keyByProps,
-};