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

package/lib/relations/RelationOwner.js

@@ -0,0 +1,236 @@
+'use strict';
+
+const { isObject, asArray, asSingle, uniqBy } = require('../utils/objectUtils');
+const { normalizeIds } = require('../utils/normalizeIds');
+
+const Type = {
+  Models: 'Models',
+  Reference: 'Reference',
+  QueryBuilder: 'QueryBuilder',
+  Identifiers: 'Identifiers',
+};
+
+class RelationOwner {
+  constructor(owner) {
+    this.owner = owner;
+    this.type = detectType(owner);
+  }
+
+  static create(owner) {
+    return new RelationOwner(owner);
+  }
+
+  static createParentReference(builder, relation) {
+    return this.create(relation.ownerProp.refs(findFirstNonPartialAncestorQuery(builder)));
+  }
+
+  get isModels() {
+    return this.type === Type.Models;
+  }
+
+  get isReference() {
+    return this.type === Type.Reference;
+  }
+
+  get isQueryBuilder() {
+    return this.type === Type.QueryBuilder;
+  }
+
+  get isIdentifiers() {
+    return this.type === Type.Identifiers;
+  }
+
+  get modelArray() {
+    return asArray(this.owner);
+  }
+
+  get model() {
+    return asSingle(this.owner);
+  }
+
+  get reference() {
+    return this.owner;
+  }
+
+  get queryBuilder() {
+    return this.owner;
+  }
+
+  get identifiers() {
+    return this.owner;
+  }
+
+  buildFindQuery(builder, relation, relatedRefs) {
+    if (this.isReference) {
+      relatedRefs.forEach((relatedRef, i) => {
+        builder.where(relatedRef, this.reference[i]);
+      });
+    } else if (this.isModels || this.isIdentifiers || this.isQueryBuilder) {
+      const values = this.getProps(relation);
+
+      if (values) {
+        builder.whereInComposite(relatedRefs, values);
+      } else {
+        builder.where(false).resolve([]);
+      }
+    } else {
+      builder.where(false).resolve([]);
+    }
+
+    return builder;
+  }
+
+  getProps(relation, ownerProp = relation.ownerProp) {
+    if (this.isModels) {
+      return this._getPropsFromModels(ownerProp);
+    } else if (this.isIdentifiers) {
+      return this._getPropsFromIdentifiers(relation, ownerProp);
+    } else if (this.isQueryBuilder) {
+      return this._getPropsFromQuery(relation, ownerProp);
+    }
+  }
+
+  getSplitProps(builder, relation, ownerProp = relation.ownerProp) {
+    const values = this.getProps(relation, relation.ownerProp);
+
+    if (isQueryBuilder(values)) {
+      if (ownerProp.size === 1) {
+        return [[values]];
+      } else {
+        // For composite keys, we need to create a query builder for each
+        // key. Each query builder only select that key.
+        return [
+          Array.from({ length: ownerProp.size }).map((_, i) => {
+            return values.clone().clearSelect().select(ownerProp.ref(builder, i));
+          }),
+        ];
+      }
+    } else {
+      return values;
+    }
+  }
+
+  getNormalizedIdentifiers(ownerProp) {
+    return normalizeIds(this.identifiers, ownerProp, {
+      arrayOutput: true,
+    });
+  }
+
+  _getPropsFromModels(ownerProp) {
+    const props = this.modelArray.map((owner) => ownerProp.getProps(owner));
+
+    if (!containsNonNull(props)) {
+      return null;
+    }
+
+    return uniqBy(props, join);
+  }
+
+  _getPropsFromIdentifiers(relation, ownerProp) {
+    const ids = this.getNormalizedIdentifiers(ownerProp);
+
+    if (isIdProp(ownerProp)) {
+      return ids;
+    } else {
+      const query = relation.ownerModelClass.query();
+
+      query.findByIds(ids);
+      query.select(ownerProp.refs(query));
+
+      return query;
+    }
+  }
+
+  _getPropsFromQuery(relation, ownerProp) {
+    const query = this.queryBuilder.clone();
+
+    if (isOwnerModelClassQuery(query, relation)) {
+      query.clearSelect();
+      query.select(ownerProp.refs(query));
+    }
+
+    return query;
+  }
+}
+
+function detectType(owner) {
+  if (isModel(owner) || isModelArray(owner)) {
+    return Type.Models;
+  } else if (isReferenceArray(owner)) {
+    return Type.Reference;
+  } else if (isQueryBuilder(owner)) {
+    return Type.QueryBuilder;
+  } else {
+    return Type.Identifiers;
+  }
+}
+
+function isModel(item) {
+  return isObject(item) && !!item.$isObjectionModel;
+}
+
+function isModelArray(item) {
+  return Array.isArray(item) && isModel(item[0]);
+}
+
+function isReference(item) {
+  return isObject(item) && !!item.isObjectionReferenceBuilder;
+}
+
+function isReferenceArray(item) {
+  return Array.isArray(item) && isReference(item[0]);
+}
+
+function isQueryBuilder(item) {
+  return isObject(item) && !!item.isObjectionQueryBuilder;
+}
+
+function findFirstNonPartialAncestorQuery(builder) {
+  builder = builder.parentQuery();
+  if (!builder)
+    throw Error(
+      'query method `for` ommitted outside a subquery, can not figure out relation target',
+    );
+  while (builder.isPartial()) {
+    if (!builder.parentQuery()) {
+      break;
+    }
+
+    builder = builder.parentQuery();
+  }
+
+  return builder;
+}
+
+function containsNonNull(arr) {
+  for (let i = 0, l = arr.length; i < l; ++i) {
+    const val = arr[i];
+
+    if (Array.isArray(val)) {
+      if (containsNonNull(val)) {
+        return true;
+      }
+    } else if (val !== null && val !== undefined) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function join(id) {
+  return id.map((x) => (Buffer.isBuffer(x) ? x.toString('hex') : x)).join(',');
+}
+
+function isIdProp(relationProp) {
+  const idProp = relationProp.modelClass.getIdRelationProperty();
+  return idProp.props.every((prop, i) => prop === relationProp.props[i]);
+}
+
+function isOwnerModelClassQuery(query, relation) {
+  return query.modelClass().getTableName() === relation.ownerModelClass.getTableName();
+}
+
+module.exports = {
+  RelationOwner,
+};

package/lib/relations/RelationProperty.js

@@ -0,0 +1,247 @@
+'use strict';
+
+const { asArray, isObject, uniqBy, get, set } = require('../utils/objectUtils');
+const { ref: createRef } = require('../queryBuilder/ReferenceBuilder');
+const { propToStr, PROP_KEY_PREFIX } = require('../model/modelValues');
+
+class ModelNotFoundError extends Error {
+  constructor(tableName) {
+    super();
+    this.name = this.constructor.name;
+    this.tableName = tableName;
+  }
+}
+
+class InvalidReferenceError extends Error {
+  constructor() {
+    super();
+    this.name = this.constructor.name;
+  }
+}
+
+// A pair of these define how two tables are related to each other.
+// Both the owner and the related table have one of these.
+//
+// A relation property can be a single column, an array of columns
+// (composite key) a json column reference, an array of json column
+// references or any combination of the above.
+class RelationProperty {
+  // references must be a reference string like `Table.column:maybe.some.json[1].path`.
+  // or an array of such references (composite key).
+  //
+  // modelClassResolver must be a function that takes a table name
+  // and returns a model class.
+  constructor(references, modelClassResolver) {
+    const refs = createRefs(asArray(references));
+    const paths = createPaths(refs, modelClassResolver);
+    const modelClass = resolveModelClass(paths);
+
+    this._refs = refs.map((ref) => ref.model(modelClass));
+    this._modelClass = modelClass;
+    this._props = paths.map((it) => it.path[0]);
+    this._cols = refs.map((it) => it.column);
+    this._propGetters = paths.map((it) => createGetter(it.path));
+    this._propSetters = paths.map((it) => createSetter(it.path));
+    this._patchers = refs.map((it, i) => createPatcher(it, paths[i].path));
+  }
+
+  static get ModelNotFoundError() {
+    return ModelNotFoundError;
+  }
+
+  static get InvalidReferenceError() {
+    return InvalidReferenceError;
+  }
+
+  // The number of columns.
+  get size() {
+    return this._refs.length;
+  }
+
+  // The model class that owns the property.
+  get modelClass() {
+    return this._modelClass;
+  }
+
+  // An array of property names. Contains multiple values in case of composite key.
+  // This may be different from `cols` if the model class has some kind of conversion
+  // between database and "external" formats, for example a snake_case to camelCase
+  // conversion.
+  get props() {
+    return this._props;
+  }
+
+  // An array of column names. Contains multiple values in case of composite key.
+  // This may be different from `props` if the model class has some kind of conversion
+  // between database and "external" formats, for example a snake_case to camelCase
+  // conversion.
+  get cols() {
+    return this._cols;
+  }
+
+  forEach(callback) {
+    for (let i = 0, l = this.size; i < l; ++i) {
+      callback(i);
+    }
+  }
+
+  // Creates a concatenated string from the property values of the given object.
+  propKey(obj) {
+    const size = this.size;
+    let key = PROP_KEY_PREFIX;
+
+    for (let i = 0; i < size; ++i) {
+      key += propToStr(this.getProp(obj, i));
+
+      if (i !== size - 1) {
+        key += ',';
+      }
+    }
+
+    return key;
+  }
+
+  // Returns the property values of the given object as an array.
+  getProps(obj) {
+    const size = this.size;
+    const props = new Array(size);
+
+    for (let i = 0; i < size; ++i) {
+      props[i] = this.getProp(obj, i);
+    }
+
+    return props;
+  }
+
+  // Returns true if the given object has a non-null value in all properties.
+  hasProps(obj) {
+    const size = this.size;
+
+    for (let i = 0; i < size; ++i) {
+      const prop = this.getProp(obj, i);
+
+      if (prop === null || prop === undefined) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  // Returns the index:th property value of the given object.
+  getProp(obj, index) {
+    return this._propGetters[index](obj);
+  }
+
+  // Sets the index:th property value of the given object.
+  setProp(obj, index, value) {
+    return this._propSetters[index](obj, value);
+  }
+
+  // Returns an instance of ReferenceBuilder that points to the index:th
+  // value of a row.
+  ref(builder, index) {
+    const table = builder.tableRefFor(this.modelClass);
+
+    return this._refs[index].clone().table(table);
+  }
+
+  // Returns an array of reference builders. `ref(builder, i)` for each i.
+  refs(builder) {
+    const refs = new Array(this.size);
+
+    for (let i = 0, l = refs.length; i < l; ++i) {
+      refs[i] = this.ref(builder, i);
+    }
+
+    return refs;
+  }
+
+  // Appends an update operation for the index:th column into `patch` object.
+  patch(patch, index, value) {
+    return this._patchers[index](patch, value);
+  }
+
+  // String representation of this property's index:th column for logging.
+  propDescription(index) {
+    return this._refs[index].expression;
+  }
+}
+
+function createRefs(refs) {
+  try {
+    return refs.map((it) => {
+      if (!isObject(it) || !it.isObjectionReferenceBuilder) {
+        return createRef(it);
+      } else {
+        return it;
+      }
+    });
+  } catch (err) {
+    throw new InvalidReferenceError();
+  }
+}
+
+function createPaths(refs, modelClassResolver) {
+  return refs.map((ref) => {
+    if (!ref.tableName) {
+      throw new InvalidReferenceError();
+    }
+
+    const modelClass = modelClassResolver(ref.tableName);
+
+    if (!modelClass) {
+      throw new ModelNotFoundError(ref.tableName);
+    }
+
+    const prop = modelClass.columnNameToPropertyName(ref.column);
+    const jsonPath = ref.parsedExpr.access.map((it) => it.ref);
+
+    return {
+      path: [prop].concat(jsonPath),
+      modelClass,
+    };
+  });
+}
+
+function resolveModelClass(paths) {
+  const modelClasses = paths.map((it) => it.modelClass);
+  const uniqueModelClasses = uniqBy(modelClasses);
+
+  if (uniqueModelClasses.length !== 1) {
+    throw new InvalidReferenceError();
+  }
+
+  return modelClasses[0];
+}
+
+function createGetter(path) {
+  if (path.length === 1) {
+    const prop = path[0];
+    return (obj) => obj[prop];
+  } else {
+    return (obj) => get(obj, path);
+  }
+}
+
+function createSetter(path) {
+  if (path.length === 1) {
+    const prop = path[0];
+    return (obj, value) => (obj[prop] = value);
+  } else {
+    return (obj, value) => set(obj, path, value);
+  }
+}
+
+function createPatcher(ref, path) {
+  if (ref.isPlainColumnRef) {
+    return (patch, value) => (patch[path[0]] = value);
+  } else {
+    // Objection `patch`, `update` etc. methods understand field expressions.
+    return (patch, value) => (patch[ref.expression] = value);
+  }
+}
+
+module.exports = {
+  RelationProperty,
+};

package/lib/relations/RelationUpdateOperation.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const { UpdateOperation } = require('../queryBuilder/operations/UpdateOperation');
+const { RelationFindOperation } = require('./RelationFindOperation');
+
+class RelationUpdateOperation extends UpdateOperation {
+  constructor(name, opt) {
+    super(name, opt);
+
+    this.relation = opt.relation;
+    this.owner = opt.owner;
+  }
+
+  onBuild(builder) {
+    super.onBuild(builder);
+
+    this.relation.findQuery(builder, this.owner);
+  }
+
+  toFindOperation() {
+    return new RelationFindOperation('find', {
+      relation: this.relation,
+      owner: this.owner,
+    });
+  }
+}
+
+module.exports = {
+  RelationUpdateOperation,
+};

package/lib/relations/belongsToOne/BelongsToOneDeleteOperation.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const { RelationDeleteOperation } = require('../RelationDeleteOperation');
+
+class BelongsToOneDeleteOperation extends RelationDeleteOperation {
+  onAfter1(_, result) {
+    if (this.owner.isModels) {
+      const ownerProp = this.relation.ownerProp;
+
+      for (const owner of this.owner.modelArray) {
+        ownerProp.forEach((i) => {
+          ownerProp.setProp(owner, i, null);
+        });
+      }
+    }
+
+    return result;
+  }
+}
+
+module.exports = {
+  BelongsToOneDeleteOperation,
+};

package/lib/relations/belongsToOne/BelongsToOneInsertOperation.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const { RelationInsertOperation } = require('../RelationInsertOperation');
+const { BelongsToOneRelateOperation } = require('./BelongsToOneRelateOperation');
+
+class BelongsToOneInsertOperation extends RelationInsertOperation {
+  onAdd(builder, args) {
+    const retVal = super.onAdd(builder, args);
+
+    if (this.models.length > 1) {
+      throw this.relation.createError('can only insert one model to a BelongsToOneRelation');
+    }
+
+    return retVal;
+  }
+
+  async onAfter1(builder, ret) {
+    const inserted = await super.onAfter1(builder, ret);
+
+    if (!builder.isExecutable()) {
+      return inserted;
+    }
+
+    const relateOp = new BelongsToOneRelateOperation('relate', {
+      relation: this.relation,
+      owner: this.owner,
+    });
+
+    if (this.assignResultToOwner && this.owner.isModels) {
+      for (const owner of this.owner.modelArray) {
+        owner.$setRelated(this.relation, inserted);
+      }
+    }
+
+    relateOp.onAdd(builder, [inserted]);
+    await relateOp.queryExecutor(builder);
+
+    return inserted;
+  }
+}
+
+module.exports = {
+  BelongsToOneInsertOperation,
+};

package/lib/relations/belongsToOne/BelongsToOneRelateOperation.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const { normalizeIds } = require('../../utils/normalizeIds');
+const { RelateOperation } = require('../../queryBuilder/operations/RelateOperation');
+
+class BelongsToOneRelateOperation extends RelateOperation {
+  onAdd(_, args) {
+    this.input = args[0];
+    this.ids = normalizeIds(args[0], this.relation.relatedProp, { arrayOutput: true });
+
+    assertOneId(this.ids);
+    return true;
+  }
+
+  queryExecutor(builder) {
+    const patch = {};
+    const ownerProp = this.relation.ownerProp;
+
+    ownerProp.forEach((i) => {
+      const relatedValue = this.ids[0][i];
+
+      if (this.owner.isModels) {
+        for (const owner of this.owner.modelArray) {
+          ownerProp.setProp(owner, i, relatedValue);
+        }
+      }
+
+      ownerProp.patch(patch, i, relatedValue);
+    });
+
+    const ownerIdProp = this.relation.ownerModelClass.getIdRelationProperty();
+    const ownerIds = this.owner.getProps(this.relation, ownerIdProp);
+
+    return this.relation.ownerModelClass
+      .query()
+      .childQueryOf(builder)
+      .patch(patch)
+      .whereInComposite(ownerIdProp.refs(builder), ownerIds);
+  }
+}
+
+function assertOneId(ids) {
+  if (ids.length > 1) {
+    throw new Error('can only relate one model to a BelongsToOneRelation');
+  }
+}
+
+module.exports = {
+  BelongsToOneRelateOperation,
+};

package/lib/relations/belongsToOne/BelongsToOneRelation.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const { Relation } = require('../Relation');
+const { BelongsToOneInsertOperation } = require('./BelongsToOneInsertOperation');
+const { BelongsToOneDeleteOperation } = require('./BelongsToOneDeleteOperation');
+const { BelongsToOneRelateOperation } = require('./BelongsToOneRelateOperation');
+const { BelongsToOneUnrelateOperation } = require('./BelongsToOneUnrelateOperation');
+
+class BelongsToOneRelation extends Relation {
+  isOneToOne() {
+    return true;
+  }
+
+  insert(_, owner) {
+    return new BelongsToOneInsertOperation('insert', {
+      relation: this,
+      owner,
+    });
+  }
+
+  delete(_, owner) {
+    return new BelongsToOneDeleteOperation('delete', {
+      relation: this,
+      owner,
+    });
+  }
+
+  relate(_, owner) {
+    return new BelongsToOneRelateOperation('relate', {
+      relation: this,
+      owner,
+    });
+  }
+
+  unrelate(_, owner) {
+    return new BelongsToOneUnrelateOperation('unrelate', {
+      relation: this,
+      owner,
+    });
+  }
+}
+
+Object.defineProperties(BelongsToOneRelation.prototype, {
+  isObjectionBelongsToOneRelation: {
+    enumerable: false,
+    writable: false,
+    value: true,
+  },
+});
+
+module.exports = {
+  BelongsToOneRelation,
+};