@abedmurrar/objection 0.0.0-stage → 4.0.0-alpha.0

package/lib/model/modelParseRelations.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const { isObject } = require('../utils/objectUtils');
+
+function parseRelationsIntoModelInstances(model, json, options = {}) {
+  if (!options.cache) {
+    options = Object.assign({}, options, {
+      cache: new Map(),
+    });
+  }
+
+  options.cache.set(json, model);
+
+  for (const relationName of model.constructor.getRelationNames()) {
+    const relationJson = json[relationName];
+
+    if (relationJson !== undefined) {
+      const relation = model.constructor.getRelation(relationName);
+      const relationModel = parseRelation(relationJson, relation, options);
+
+      if (relationModel !== relationJson) {
+        model[relation.name] = relationModel;
+      }
+    }
+  }
+
+  return model;
+}
+
+function parseRelation(json, relation, options) {
+  if (Array.isArray(json)) {
+    return parseRelationArray(json, relation, options);
+  } else if (json) {
+    return parseRelationObject(json, relation, options);
+  } else {
+    return null;
+  }
+}
+
+function parseRelationArray(json, relation, options) {
+  const models = new Array(json.length);
+  let didChange = false;
+
+  for (let i = 0, l = json.length; i < l; ++i) {
+    const model = parseRelationObject(json[i], relation, options);
+
+    if (model !== json[i]) {
+      didChange = true;
+    }
+
+    models[i] = model;
+  }
+
+  if (didChange) {
+    return models;
+  } else {
+    return json;
+  }
+}
+
+function parseRelationObject(json, relation, options) {
+  if (isObject(json)) {
+    const modelClass = relation.relatedModelClass;
+    let model = options.cache.get(json);
+
+    if (model === undefined) {
+      if (json instanceof modelClass) {
+        model = parseRelationsIntoModelInstances(json, json, options);
+      } else {
+        model = modelClass.fromJson(json, options);
+      }
+    }
+
+    return model;
+  } else {
+    return json;
+  }
+}
+
+module.exports = {
+  parseRelationsIntoModelInstances,
+};

package/lib/model/modelQueryProps.js

@@ -0,0 +1,147 @@
+'use strict';
+
+const { isObject, isFunction } = require('../utils/objectUtils');
+const { defineNonEnumerableProperty } = require('./modelUtils');
+const { isKnexRaw, isKnexQueryBuilder } = require('../utils/knexUtils');
+
+const QUERY_PROPS_PROPERTY = '$$queryProps';
+
+// Removes query properties from `json` and stores them into a hidden property
+// inside `model` so that they can be later merged back to `json`.
+function splitQueryProps(model, json) {
+  const keys = Object.keys(json);
+
+  if (hasQueryProps(json, keys)) {
+    const queryProps = {};
+    const modelProps = {};
+
+    for (let i = 0, l = keys.length; i < l; ++i) {
+      const key = keys[i];
+      const value = json[key];
+
+      if (isQueryProp(value)) {
+        queryProps[key] = value;
+      } else {
+        modelProps[key] = value;
+      }
+    }
+
+    defineNonEnumerableProperty(model, QUERY_PROPS_PROPERTY, queryProps);
+
+    return modelProps;
+  } else {
+    return json;
+  }
+}
+
+function hasQueryProps(json, keys) {
+  for (let i = 0, l = keys.length; i < l; ++i) {
+    if (isQueryProp(json[keys[i]])) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function isQueryProp(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+
+  return (
+    isKnexQueryBuilder(value) ||
+    isKnexRaw(value) ||
+    isKnexRawConvertable(value) ||
+    value.isObjectionQueryBuilderBase
+  );
+}
+
+// Merges and converts `model`'s query properties into `json`.
+function mergeQueryProps(model, json, omitProps, builder) {
+  json = convertExistingQueryProps(json, builder);
+  json = convertAndMergeHiddenQueryProps(model, json, omitProps, builder);
+
+  return json;
+}
+
+// Converts the query properties in `json` to knex raw instances.
+// `json` may have query properties even though we removed them.
+// For example they may have been added in lifecycle hooks.
+function convertExistingQueryProps(json, builder) {
+  const keys = Object.keys(json);
+
+  for (let i = 0, l = keys.length; i < l; ++i) {
+    const key = keys[i];
+    const value = json[key];
+
+    if (isQueryProp(value)) {
+      json[key] = queryPropToKnexRaw(value, builder);
+    }
+  }
+
+  return json;
+}
+
+// Converts and merges the query props that were split from the model
+// and stored into QUERY_PROPS_PROPERTY.
+function convertAndMergeHiddenQueryProps(model, json, omitProps, builder) {
+  const queryProps = model[QUERY_PROPS_PROPERTY];
+
+  if (!queryProps) {
+    // The model has no query properties.
+    return json;
+  }
+
+  const modelClass = model.constructor;
+  const keys = Object.keys(queryProps);
+
+  for (let i = 0, l = keys.length; i < l; ++i) {
+    const key = keys[i];
+
+    if (!omitProps || !omitProps.includes(key)) {
+      const queryProp = queryPropToKnexRaw(queryProps[key], builder);
+      json[modelClass.propertyNameToColumnName(key)] = queryProp;
+    }
+  }
+
+  return json;
+}
+
+// Converts a query property into a knex `raw` instance.
+function queryPropToKnexRaw(queryProp, builder) {
+  if (!queryProp) {
+    return queryProp;
+  }
+
+  if (queryProp.isObjectionQueryBuilderBase) {
+    return buildObjectionQueryBuilder(queryProp, builder);
+  } else if (isKnexRawConvertable(queryProp)) {
+    return buildKnexRawConvertable(queryProp, builder);
+  } else {
+    return queryProp;
+  }
+}
+
+function buildObjectionQueryBuilder(builder, parentBuilder) {
+  return builder.subqueryOf(parentBuilder).toKnexQuery();
+}
+
+function buildKnexRawConvertable(convertable, builder) {
+  if (!builder) {
+    throw new Error(
+      'toDatabaseJson called without a query builder instance for a model with query properties',
+    );
+  }
+
+  return convertable.toKnexRaw(builder);
+}
+
+function isKnexRawConvertable(queryProp) {
+  return isFunction(queryProp.toKnexRaw);
+}
+
+module.exports = {
+  splitQueryProps,
+  mergeQueryProps,
+};

package/lib/model/modelSet.js

@@ -0,0 +1,136 @@
+'use strict';
+
+const { isInternalProp } = require('../utils/internalPropUtils');
+const { splitQueryProps } = require('./modelQueryProps');
+const { isFunction, isString, isPlainObject } = require('../utils/objectUtils');
+const { parseRelationsIntoModelInstances } = require('./modelParseRelations');
+
+function setJson(model, json, options) {
+  json = json || {};
+  options = options || {};
+
+  if (Object.prototype.toString.call(json) !== '[object Object]') {
+    throw new Error(
+      'You should only pass objects to $setJson method. ' +
+        '$setJson method was given an invalid value ' +
+        json,
+    );
+  }
+
+  if (!json.$isObjectionModel) {
+    // json can contain "query properties" like `raw` instances, query builders etc.
+    // We take them out of `json` and store them to a hidden property $$queryProps
+    // in the model instance for later use.
+    json = splitQueryProps(model, json);
+  }
+
+  json = model.$parseJson(json, options);
+  json = model.$validate(json, options);
+
+  model.$set(json);
+
+  if (!options.skipParseRelations) {
+    parseRelationsIntoModelInstances(model, json, options);
+  }
+
+  return model;
+}
+
+function setDatabaseJson(model, json) {
+  json = model.$parseDatabaseJson(json);
+
+  if (json) {
+    const keys = Object.keys(json);
+
+    for (let i = 0, l = keys.length; i < l; ++i) {
+      const key = keys[i];
+      model[key] = json[key];
+    }
+  }
+
+  return model;
+}
+
+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
+    // serialized from a model instance.
+    const readOnlyAttr = model.constructor.getReadOnlyAttributes();
+    const keys = Object.keys(obj);
+
+    for (let i = 0, l = keys.length; i < l; ++i) {
+      const key = keys[i];
+      const value = obj[key];
+
+      if (
+        (value !== undefined || isPlainObject(obj)) &&
+        !isInternalProp(key) &&
+        !isFunction(value) &&
+        !readOnlyAttr.includes(key)
+      ) {
+        model[key] = value;
+      }
+    }
+  }
+
+  return model;
+}
+
+function setRelated(model, relation, models) {
+  relation = ensureRelation(model, relation);
+
+  if (relation.isOneToOne()) {
+    if (Array.isArray(models)) {
+      if (models.length === 0) {
+        model[relation.name] = null;
+      } else {
+        model[relation.name] = models[0] || null;
+      }
+    } else {
+      model[relation.name] = models || null;
+    }
+  } else {
+    if (!models) {
+      model[relation.name] = [];
+    } else if (Array.isArray(models)) {
+      model[relation.name] = models;
+    } else {
+      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) {
+  if (isString(relation)) {
+    return model.constructor.getRelation(relation);
+  } else {
+    return relation;
+  }
+}
+
+module.exports = {
+  setFast,
+  setJson,
+  setDatabaseJson,
+  setRelated,
+  appendRelated,
+};

package/lib/model/modelTableMetadata.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const { defineNonEnumerableProperty } = require('./modelUtils');
+const { isPromise } = require('../utils/promiseUtils');
+
+const TABLE_METADATA = '$$tableMetadata';
+
+function fetchTableMetadata(
+  modelClass,
+  { parentBuilder = null, knex = null, force = false, table = null } = {},
+) {
+  // The table isn't necessarily same as `modelClass.getTableName()` for example if
+  // a view is queried instead.
+  if (!table) {
+    if (parentBuilder) {
+      table = parentBuilder.tableNameFor(modelClass);
+    } else {
+      table = modelClass.getTableName();
+    }
+  }
+
+  // Call tableMetadata first instead of accessing the cache directly beause
+  // tableMetadata may have been overriden.
+  let metadata = modelClass.tableMetadata({ table });
+
+  if (!force && metadata) {
+    return Promise.resolve(metadata);
+  }
+
+  // Memoize metadata but only for modelClass. The hasOwnProperty check
+  // will fail for subclasses and the value gets recreated.
+  if (!modelClass.hasOwnProperty(TABLE_METADATA)) {
+    defineNonEnumerableProperty(modelClass, TABLE_METADATA, new Map());
+  }
+
+  // The cache needs to be checked in addition to calling tableMetadata
+  // because the cache may contain a temporary promise in which case
+  // tableMetadata returns null.
+  metadata = modelClass[TABLE_METADATA].get(table);
+
+  if (!force && metadata) {
+    return Promise.resolve(metadata);
+  } else {
+    const promise = modelClass
+      .query(knex)
+      .childQueryOf(parentBuilder)
+      .columnInfo({ table })
+      .then((columnInfo) => {
+        const metadata = {
+          columns: Object.keys(columnInfo),
+        };
+
+        modelClass[TABLE_METADATA].set(table, metadata);
+        return metadata;
+      })
+      .catch((err) => {
+        modelClass[TABLE_METADATA].delete(table);
+        throw err;
+      });
+
+    modelClass[TABLE_METADATA].set(table, promise);
+    return promise;
+  }
+}
+
+function tableMetadata(modelClass, { table } = {}) {
+  if (modelClass.hasOwnProperty(TABLE_METADATA)) {
+    const metadata = modelClass[TABLE_METADATA].get(table || modelClass.getTableName());
+
+    if (isPromise(metadata)) {
+      return null;
+    } else {
+      return metadata;
+    }
+  } else {
+    return null;
+  }
+}
+
+module.exports = {
+  fetchTableMetadata,
+  tableMetadata,
+};

package/lib/model/modelToJson.js

@@ -0,0 +1,187 @@
+'use strict';
+
+const { isInternalProp } = require('../utils/internalPropUtils');
+const { mergeQueryProps } = require('./modelQueryProps');
+const { isObject, cloneDeep, isFunction } = require('../utils/objectUtils');
+const EMPTY_ARRAY = [];
+
+function toJson(model, optIn) {
+  const modelClass = model.constructor;
+
+  const opt = {
+    virtuals: getVirtuals(optIn),
+    shallow: isShallow(optIn),
+    omit: getOmit(optIn, modelClass),
+    pick: null,
+    omitFromJson: model.$omitFromJson() || null,
+    cloneObjects: modelClass.cloneObjectAttributes,
+  };
+
+  let json = toExternalJsonImpl(model, opt);
+  json = model.$formatJson(json);
+
+  return json;
+}
+
+function toDatabaseJson(model, builder) {
+  const modelClass = model.constructor;
+
+  const opt = {
+    virtuals: false,
+    shallow: true,
+    omit: modelClass.getRelationNames(),
+    pick: getPick(modelClass),
+    omitFromJson: model.$omitFromDatabaseJson() || null,
+    cloneObjects: modelClass.cloneObjectAttributes,
+  };
+
+  let json = toDatabaseJsonImpl(model, opt);
+  json = model.$formatDatabaseJson(json);
+
+  return mergeQueryProps(model, json, opt.omitFromJson, builder);
+}
+
+function getVirtuals(opt) {
+  if (!opt) {
+    return true;
+  } else if (Array.isArray(opt.virtuals)) {
+    return opt.virtuals;
+  } else {
+    return opt.virtuals !== false;
+  }
+}
+
+function isShallow(opt) {
+  return !!opt && !!opt.shallow;
+}
+
+function getOmit(opt, modelClass) {
+  return isShallow(opt) ? modelClass.getRelationNames() : null;
+}
+
+function getPick(modelClass) {
+  const jsonSchema = modelClass.getJsonSchema();
+  return (jsonSchema && modelClass.pickJsonSchemaProperties && jsonSchema.properties) || null;
+}
+
+function toExternalJsonImpl(model, opt) {
+  const json = {};
+  const keys = Object.keys(model);
+  const vAttr = getVirtualAttributes(model, opt);
+
+  for (let i = 0, l = keys.length; i < l; ++i) {
+    const key = keys[i];
+    const value = model[key];
+
+    assignJsonValue(json, key, value, opt);
+  }
+
+  if (vAttr.length !== 0) {
+    assignVirtualAttributes(json, model, vAttr, opt);
+  }
+
+  return json;
+}
+
+function getVirtualAttributes(model, opt) {
+  if (Array.isArray(opt.virtuals)) {
+    return opt.virtuals;
+  } else if (opt.virtuals === true) {
+    return model.constructor.getVirtualAttributes();
+  } else {
+    return EMPTY_ARRAY;
+  }
+}
+
+function toDatabaseJsonImpl(model, opt) {
+  const json = {};
+  const keys = Object.keys(model);
+
+  for (let i = 0, l = keys.length; i < l; ++i) {
+    const key = keys[i];
+    const value = model[key];
+
+    assignJsonValue(json, key, value, opt);
+  }
+
+  return json;
+}
+
+function assignJsonValue(json, key, value, opt) {
+  const type = typeof value;
+
+  if (
+    type !== 'function' &&
+    type !== 'undefined' &&
+    !isInternalProp(key) &&
+    !shouldOmit(opt, key) &&
+    shouldPick(opt, key)
+  ) {
+    if (isObject(value)) {
+      json[key] = toJsonObject(value, opt);
+    } else {
+      json[key] = value;
+    }
+  }
+}
+
+function shouldOmit(opt, key) {
+  return (
+    (opt.omit !== null && opt.omit.includes(key)) ||
+    (opt.omitFromJson !== null && opt.omitFromJson.includes(key))
+  );
+}
+
+function shouldPick(opt, key) {
+  return opt.pick === null || key in opt.pick;
+}
+
+function assignVirtualAttributes(json, model, vAttr, opt) {
+  for (let i = 0, l = vAttr.length; i < l; ++i) {
+    const key = vAttr[i];
+    let value = model[key];
+
+    if (isFunction(value)) {
+      value = value.call(model);
+    }
+
+    assignJsonValue(json, key, value, opt);
+  }
+}
+
+function toJsonObject(value, opt) {
+  if (Array.isArray(value)) {
+    return toJsonArray(value, opt);
+  } else if (value.$isObjectionModel) {
+    // No branch for $toDatabaseJson here since there is never a need
+    // to have nested models in database rows.
+    return value.$toJson(opt);
+  } else if (Buffer.isBuffer(value)) {
+    return value;
+  } else if (opt.cloneObjects) {
+    return cloneDeep(value);
+  } else {
+    return value;
+  }
+}
+
+function toJsonArray(value, opt) {
+  const ret = new Array(value.length);
+
+  for (let i = 0, l = ret.length; i < l; ++i) {
+    const item = value[i];
+
+    if (isObject(item)) {
+      ret[i] = toJsonObject(item, opt);
+    } else {
+      ret[i] = item;
+    }
+  }
+
+  return ret;
+}
+
+module.exports = {
+  toJson,
+  toDatabaseJson,
+};

package/lib/model/modelUtils.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const hiddenProps = ['$$queryProps'];
+
+const staticHiddenProps = [
+  '$$knex',
+  '$$validator',
+  '$$jsonSchema',
+  '$$colToProp',
+  '$$propToCol',
+  '$$relationMappings',
+  '$$relations',
+  '$$relationNames',
+  '$$jsonAttributes',
+  '$$columnNameMappers',
+  '$$tableMetadata',
+  '$$readOnlyAttributes',
+  '$$idRelationProperty',
+  '$$virtualAttributes',
+];
+
+function defineNonEnumerableProperty(obj, prop, value) {
+  Object.defineProperty(obj, prop, {
+    enumerable: false,
+    writable: true,
+    configurable: true,
+    value,
+  });
+}
+
+function keyByProps(models, props) {
+  const map = new Map();
+
+  for (let i = 0, l = models.length; i < l; ++i) {
+    const model = models[i];
+    map.set(model.$propKey(props), model);
+  }
+
+  return map;
+}
+
+module.exports = {
+  hiddenProps,
+  staticHiddenProps,
+  defineNonEnumerableProperty,
+  keyByProps,
+};