@abedmurrar/objection 4.0.0-alpha.0 → 4.0.0-beta.1

package/lib/relations/RelationOwner.js

@@ -1,236 +1,202 @@
-'use strict';
-
-const { isObject, asArray, asSingle, uniqBy } = require('../utils/objectUtils');
-const { normalizeIds } = require('../utils/normalizeIds');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationOwner = void 0;
+const objectUtils_1 = require("../utils/objectUtils");
+const normalizeIds_1 = require("../utils/normalizeIds");
 const Type = {
-  Models: 'Models',
-  Reference: 'Reference',
-  QueryBuilder: 'QueryBuilder',
-  Identifiers: 'Identifiers',
+    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;
-  }
+    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 (0, objectUtils_1.asArray)(this.owner);
+    }
+    get model() {
+        return (0, objectUtils_1.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;
+    }
+    // Returns an array of value arrays (one per owner), or a query builder
+    // that selects them.
+    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 (0, normalizeIds_1.normalizeIds)(this.identifiers, ownerProp, {
+            arrayOutput: true,
+        });
+    }
+    _getPropsFromModels(ownerProp) {
+        const props = this.modelArray.map((owner) => ownerProp.getProps(owner));
+        if (!containsNonNull(props)) {
+            return null;
+        }
+        return (0, objectUtils_1.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;
+    }
 }
-
+exports.RelationOwner = RelationOwner;
 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;
-  }
+    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;
+    return (0, objectUtils_1.isObject)(item) && !!item.$isObjectionModel;
 }
-
 function isModelArray(item) {
-  return Array.isArray(item) && isModel(item[0]);
+    return Array.isArray(item) && isModel(item[0]);
 }
-
 function isReference(item) {
-  return isObject(item) && !!item.isObjectionReferenceBuilder;
+    return ((0, objectUtils_1.isObject)(item) &&
+        !!item.isObjectionReferenceBuilder);
 }
-
 function isReferenceArray(item) {
-  return Array.isArray(item) && isReference(item[0]);
+    return Array.isArray(item) && isReference(item[0]);
 }
-
 function isQueryBuilder(item) {
-  return isObject(item) && !!item.isObjectionQueryBuilder;
+    return ((0, objectUtils_1.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;
+    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;
+    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(',');
+    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]);
+    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();
+    return query.modelClass().getTableName() === relation.ownerModelClass.getTableName();
 }
-
-module.exports = {
-  RelationOwner,
-};