objection 3.9.1 → 4.0.0-rc.2

package/lib/queryBuilder/graph/patch/GraphPatchAction.js

@@ -1,289 +0,0 @@
-'use strict';
-
-const { getModel } = require('../../../model/getModel');
-const { GraphAction } = require('../GraphAction');
-const { isInternalProp } = require('../../../utils/internalPropUtils');
-const { difference, isObject, isPlainObject, jsonEquals } = require('../../../utils/objectUtils');
-const promiseUtils = require('../../../utils/promiseUtils');
-
-class GraphPatchAction extends GraphAction {
-  constructor(graphData, { nodes }) {
-    super(graphData);
-    // Nodes to patch.
-    this.nodes = nodes;
-  }
-
-  run(builder) {
-    return promiseUtils.map(this.nodes, (node) => this._runForNode(builder, node), {
-      concurrency: this._getConcurrency(builder, this.nodes),
-    });
-  }
-
-  _runForNode(builder, node) {
-    const shouldPatch = this.graphOptions.shouldPatch(node, this.graphData);
-    const shouldUpdate = this.graphOptions.shouldUpdate(node, this.graphData);
-
-    // BelongsToOneRelation inserts and relates change the parent object's
-    // properties. That's why we handle them here.
-    const changedPropsBecauseOfBelongsToOneInsert = this._handleBelongsToOneInserts(node);
-
-    // BelongsToOneRelation deletes and unrelates change the parent object's
-    // properties. That's why we handle them here.
-    const changePropsBecauseOfBelongsToOneDelete = this._handleBelongsToOneDeletes(node);
-
-    // HasManyRelation and HasOneRelation relates write the related object's
-    // foreign keys, also with `noUpdate`.
-    const changedPropsBecauseOfRelate =
-      this.graphOptions.shouldRelate(node, this.graphData) &&
-      node.parentEdge.relation.isObjectionHasManyRelation
-        ? node.parentEdge.relation.relatedProp.props
-        : [];
-
-    const handleUpdate = () => {
-      const { changedProps, unchangedProps } = this._findChanges(node);
-      const allProps = [...changedProps, ...unchangedProps];
-
-      const propsToUpdate = difference(
-        shouldPatch || shouldUpdate
-          ? changedProps
-          : [
-              ...changedPropsBecauseOfBelongsToOneInsert,
-              ...changePropsBecauseOfBelongsToOneDelete,
-              ...changedPropsBecauseOfRelate,
-            ],
-
-        // Remove id properties from the props to update. With upsertGraph
-        // it never makes sense to change the id.
-        node.modelClass.getIdPropertyArray(),
-      );
-
-      const update = propsToUpdate.length > 0;
-      if (update) {
-        // Don't update the fields that we know not to change.
-        node.obj.$omitFromDatabaseJson(difference(allProps, propsToUpdate));
-        node.userData.updated = true;
-      }
-
-      return update;
-    };
-
-    const Model = getModel();
-    // See if the model defines a beforeUpdate or $beforeUpdate hook. If it does
-    // not, we can check for updated properties now and drop out immediately if
-    // there is nothing to update. Otherwise, we need to wait for the hook to be
-    // called before calling handleUpdate, but only if the node contains changes
-    // that aren't id properties (relates). See issues #2233, #2605.
-    const hasBeforeUpdate =
-      node.obj.constructor.beforeUpdate !== Model.beforeUpdate ||
-      node.obj.$beforeUpdate !== Model.prototype.$beforeUpdate;
-
-    if (
-      (hasBeforeUpdate && !this._hasNonIdPropertyChanges(node)) ||
-      (!hasBeforeUpdate && !handleUpdate())
-    ) {
-      return null;
-    }
-
-    delete node.obj[node.modelClass.uidProp];
-    delete node.obj[node.modelClass.uidRefProp];
-    delete node.obj[node.modelClass.dbRefProp];
-    delete node.obj[node.modelClass.graphUnrelateProp];
-    delete node.obj[node.modelClass.graphDeleteProp];
-
-    node.obj.$validate(null, {
-      dataPath: node.dataPathKey,
-      patch: shouldPatch || (!shouldPatch && !shouldUpdate),
-    });
-
-    const updateBuilder = this._createBuilder(node)
-      .childQueryOf(builder, childQueryOptions())
-      // The current graph was fetched through the relations, so the patched
-      // models are known to be related to their parents.
-      .internalOptions({ skipRelationFilter: true })
-      .copyFrom(builder, GraphAction.ReturningAllSelector);
-
-    if (hasBeforeUpdate) {
-      updateBuilder.internalContext().runBefore.push((result, builder) => {
-        // Call handleUpdate in the runBefore hook which runs after the
-        // $beforeUpdate hook, allowing it to modify the object before the
-        // updated properties are determined. See issue #2233.
-        if (hasBeforeUpdate && !handleUpdate()) {
-          builder.internalOptions().returnImmediatelyValue = null;
-        }
-        return result;
-      });
-    }
-
-    if (shouldPatch) {
-      updateBuilder.patch(node.obj);
-    } else {
-      updateBuilder.update(node.obj);
-    }
-
-    return updateBuilder.execute().then((result) => {
-      if (isObject(result) && result.$isObjectionModel) {
-        // Handle returning('*').
-        node.obj.$set(result);
-      }
-
-      return result;
-    });
-  }
-
-  _handleBelongsToOneInserts(node) {
-    const currentNode = this.currentGraph.nodeForNode(node);
-    const updatedProps = [];
-
-    for (const edge of node.edges) {
-      if (
-        edge.isOwnerNode(node) &&
-        edge.relation &&
-        edge.relation.isObjectionBelongsToOneRelation &&
-        edge.relation.relatedProp.hasProps(edge.relatedNode.obj) &&
-        // Ignored models don't replace the current one, and models marked with
-        // `#unrelate` or `#delete` are handled below.
-        !this.graphOptions.shouldIgnore(edge.relatedNode, this.graphData)
-      ) {
-        const { relation } = edge;
-
-        relation.ownerProp.forEach((i) => {
-          const currentValue = currentNode && relation.ownerProp.getProp(currentNode.obj, i);
-          const relatedValue = relation.relatedProp.getProp(edge.relatedNode.obj, i);
-
-          if (currentValue != relatedValue) {
-            relation.ownerProp.setProp(node.obj, i, relatedValue);
-            updatedProps.push(relation.ownerProp.props[i]);
-          }
-        });
-      }
-    }
-
-    return updatedProps;
-  }
-
-  _handleBelongsToOneDeletes(node) {
-    const currentNode = this.currentGraph.nodeForNode(node);
-    const updatedProps = [];
-
-    if (!currentNode) {
-      return updatedProps;
-    }
-
-    for (const edge of currentNode.edges) {
-      if (
-        edge.isOwnerNode(currentNode) &&
-        edge.relation.isObjectionBelongsToOneRelation &&
-        (node.obj[edge.relation.name] === null ||
-          isToBeUnrelatedOrDeleted(this.graph.nodeForNode(edge.relatedNode))) &&
-        this.graphOptions.shouldDeleteOrUnrelate(edge.relatedNode, this.graphData)
-      ) {
-        const { relation } = edge;
-
-        relation.ownerProp.forEach((i) => {
-          const currentValue = relation.ownerProp.getProp(currentNode.obj, i);
-
-          if (currentValue != null) {
-            relation.ownerProp.setProp(node.obj, i, null);
-            updatedProps.push(relation.ownerProp.props[i]);
-          }
-        });
-      }
-    }
-
-    return updatedProps;
-  }
-
-  _findChanges(node) {
-    const obj = node.obj;
-    const currentNode = this.currentGraph.nodeForNode(node);
-    const currentObj = (currentNode && currentNode.obj) || {};
-    const relationNames = node.modelClass.getRelationNames();
-
-    const unchangedProps = [];
-    const changedProps = [];
-
-    for (const prop of Object.keys(obj)) {
-      if (isInternalProp(prop) || relationNames.includes(prop)) {
-        continue;
-      }
-
-      const value = obj[prop];
-      const currentValue = currentObj[prop];
-
-      // If the current object doesn't have the property, we have to assume
-      // it changes (we cannot know if it will). If the object does have the
-      // property, we test non-strict equality. See issue #732.
-      if (currentValue === undefined || !nonStrictEquals(currentValue, value)) {
-        changedProps.push(prop);
-      } else {
-        unchangedProps.push(prop);
-      }
-    }
-
-    // We cannot know if the query properties cause changes to the values.
-    // We must assume that they do.
-    if (obj.$$queryProps) {
-      changedProps.push(...Object.keys(obj.$$queryProps));
-    }
-
-    return {
-      changedProps,
-      unchangedProps,
-    };
-  }
-
-  _hasNonIdPropertyChanges(node) {
-    const idProps = node.modelClass.getIdPropertyArray();
-    return this._findChanges(node).changedProps.some((prop) => !idProps.includes(prop));
-  }
-
-  _createBuilder(node) {
-    if (node.parentEdge && !node.parentEdge.relation.isObjectionHasManyRelation) {
-      return this._createRelatedBuilder(node);
-    } else {
-      return this._createRootBuilder(node);
-    }
-  }
-
-  _createRelatedBuilder(node) {
-    return node.parentNode.obj
-      .$relatedQuery(node.parentEdge.relation.name)
-      .findById(node.obj.$id());
-  }
-
-  _createRootBuilder(node) {
-    const currentNode = this.currentGraph.nodeForNode(node);
-    const currentObj = currentNode && currentNode.obj;
-
-    return currentObj ? currentObj.$query() : node.obj.$query();
-  }
-}
-
-function childQueryOptions() {
-  return {
-    fork: true,
-    isInternalQuery: true,
-  };
-}
-
-function nonStrictEquals(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;
-}
-
-module.exports = {
-  GraphPatchAction,
-};

package/lib/queryBuilder/graph/recursiveUpsert/GraphRecursiveUpsert.js

@@ -1,31 +0,0 @@
-'use strict';
-
-const { GraphOperation } = require('../GraphOperation');
-const { GraphRecursiveUpsertAction } = require('./GraphRecursiveUpsertAction');
-
-class GraphRecursiveUpsert extends GraphOperation {
-  createActions() {
-    return [
-      new GraphRecursiveUpsertAction(this.graphData, {
-        nodes: this.graph.nodes.filter((node) => {
-          const shouldRelate = this.graphOptions.shouldRelate(node, this.graphData);
-          return shouldRelate && hasRelations(node.obj);
-        }),
-      }),
-    ];
-  }
-}
-
-function hasRelations(obj) {
-  for (const relationName of obj.constructor.getRelationNames()) {
-    if (obj[relationName] !== undefined) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-module.exports = {
-  GraphRecursiveUpsert,
-};

package/lib/queryBuilder/graph/recursiveUpsert/GraphRecursiveUpsertAction.js

@@ -1,126 +0,0 @@
-'use strict';
-
-const { GraphAction } = require('../GraphAction');
-const { groupBy, get, set } = require('../../../utils/objectUtils');
-const { forEachPropertyReference } = require('../../../model/graph/ModelGraphBuilder');
-const promiseUtils = require('../../../utils/promiseUtils');
-
-class GraphRecursiveUpsertAction extends GraphAction {
-  constructor(graphData, { nodes }) {
-    super(graphData);
-    // Nodes to upsert.
-    this.nodes = nodes;
-  }
-
-  run(builder) {
-    const builders = this._createUpsertBuilders(builder, this.nodes);
-
-    return promiseUtils.map(builders, (builder) => builder.execute(), {
-      concurrency: this._getConcurrency(builder, this.nodes),
-    });
-  }
-
-  _createUpsertBuilders(parentBuilder, nodesToUpsert) {
-    const nodesByRelation = groupBy(nodesToUpsert, getRelation);
-    const builders = [];
-
-    nodesByRelation.forEach((nodes) => {
-      const nodesByParent = groupBy(nodes, getParent);
-
-      nodesByParent.forEach((nodes) => {
-        for (const node of nodes) {
-          this._resolveReferences(node);
-          node.userData.upserted = true;
-        }
-
-        builders.push(
-          nodes[0].modelClass
-            .query()
-            .childQueryOf(parentBuilder)
-            .copyFrom(parentBuilder, GraphAction.ReturningAllSelector)
-            .upsertGraph(
-              nodes.map((node) => node.obj),
-              this.graphOptions.rebasedOptions(nodes[0]),
-            ),
-        );
-      });
-    });
-
-    return builders;
-  }
-
-  /**
-   * The nodes inside the subgraph we are about to recursively upsert may
-   * have references outside that graph that won't be available during the
-   * recursive upsertGraph call. This method resolves the references.
-   *
-   * TODO: This doesn't work if a recursively upserted node refers to
-   *       a node inside another recursively upsertable graph.
-   */
-  _resolveReferences(node) {
-    node.obj.$traverse((obj) => this._resolveReferencesForObject(obj));
-  }
-
-  _resolveReferencesForObject(obj) {
-    this._resolveObjectReference(obj);
-    this._resolvePropertyReferences(obj);
-  }
-
-  _resolveObjectReference(obj) {
-    const modelClass = obj.constructor;
-    const ref = obj[modelClass.uidRefProp];
-
-    if (!ref) {
-      return;
-    }
-
-    const referencedNode = this.graph.nodes.find((it) => it.uid === ref);
-
-    if (!referencedNode) {
-      return;
-    }
-
-    const relationNames = referencedNode.modelClass.getRelationNames();
-
-    for (const prop of Object.keys(referencedNode.obj)) {
-      if (relationNames.includes(prop)) {
-        continue;
-      }
-
-      obj[prop] = referencedNode.obj[prop];
-    }
-
-    delete obj[modelClass.uidRefProp];
-  }
-
-  _resolvePropertyReferences(obj) {
-    forEachPropertyReference(obj, ({ path, refMatch, ref, refPath }) => {
-      const referencedNode = this.graph.nodes.find((it) => it.uid === ref);
-
-      if (!referencedNode) {
-        return;
-      }
-
-      const referencedValue = get(referencedNode.obj, refPath);
-      const value = get(obj, path);
-
-      if (value === refMatch) {
-        set(obj, path, referencedValue);
-      } else {
-        set(obj, path, value.replace(refMatch, referencedValue));
-      }
-    });
-  }
-}
-
-function getRelation(node) {
-  return node.parentEdge.relation;
-}
-
-function getParent(node) {
-  return node.parentNode;
-}
-
-module.exports = {
-  GraphRecursiveUpsertAction,
-};

package/lib/queryBuilder/operations/jsonApi/WhereJsonHasPostgresOperation.js

@@ -1,30 +0,0 @@
-'use strict';
-
-const jsonApi = require('./postgresJsonApi');
-const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConvertingOperation');
-
-class WhereJsonHasPostgresOperation extends ObjectionToKnexConvertingOperation {
-  onBuildKnex(knexBuilder, builder) {
-    jsonApi.warnIfNotPostgres(builder.knex());
-    const args = this.getKnexArgs(builder);
-
-    const rawArgs = jsonApi.whereJsonFieldRightStringArrayOnLeftQuery(
-      builder.knex(),
-      args[0],
-      this.opt.operator,
-      args[1],
-    );
-
-    if (this.opt.bool === 'or') {
-      knexBuilder = knexBuilder.orWhereRaw(...rawArgs);
-    } else {
-      knexBuilder = knexBuilder.whereRaw(...rawArgs);
-    }
-
-    return knexBuilder;
-  }
-}
-
-module.exports = {
-  WhereJsonHasPostgresOperation,
-};

package/lib/queryBuilder/operations/jsonApi/WhereJsonNotObjectPostgresOperation.js

@@ -1,37 +0,0 @@
-'use strict';
-
-const jsonApi = require('./postgresJsonApi');
-const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConvertingOperation');
-
-class WhereJsonNotObjectPostgresOperation extends ObjectionToKnexConvertingOperation {
-  onBuildKnex(knexBuilder, builder) {
-    jsonApi.warnIfNotPostgres(builder.knex());
-    return this.whereJsonNotObject(knexBuilder, builder.knex(), this.getKnexArgs(builder)[0]);
-  }
-
-  whereJsonNotObject(knexBuilder, knex, fieldExpression) {
-    const innerQuery = (innerQuery) => {
-      const builder = jsonApi.whereJsonbRefOnLeftJsonbValOrRefOnRight(
-        innerQuery,
-        fieldExpression,
-        '@>',
-        this.opt.compareValue,
-        'not',
-      );
-
-      builder.orWhereRaw(...jsonApi.whereJsonFieldQuery(knex, fieldExpression, 'IS', null));
-    };
-
-    if (this.opt.bool === 'or') {
-      knexBuilder = knexBuilder.orWhere(innerQuery);
-    } else {
-      knexBuilder = knexBuilder.where(innerQuery);
-    }
-
-    return knexBuilder;
-  }
-}
-
-module.exports = {
-  WhereJsonNotObjectPostgresOperation,
-};

package/lib/queryBuilder/operations/jsonApi/WhereJsonPostgresOperation.js

@@ -1,62 +0,0 @@
-'use strict';
-
-const jsonApi = require('./postgresJsonApi');
-const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConvertingOperation');
-const { parseFieldExpression } = require('../../../utils/parseFieldExpression');
-const { isPlainObject, isString, isFunction } = require('../../../utils/objectUtils');
-const { isMySql } = require('../../../utils/knexUtils');
-
-class WhereJsonPostgresOperation extends ObjectionToKnexConvertingOperation {
-  onBuildKnex(knexBuilder, builder) {
-    const knex = builder.knex();
-
-    if (isMySql(knex) && this.canDelegateToKnex(knexBuilder)) {
-      // On MySQL, knex's version of the method works (ditojs#113). The `or`
-      // variants are wrapped in `orWhere()`, as knex < 3 ignores their `or`.
-      const [column, value] = this.getKnexArgs(builder);
-      const { knexMethod } = this.opt;
-
-      if (this.opt.bool === 'or') {
-        return knexBuilder.orWhere((qb) => qb[knexMethod](column, value));
-      } else {
-        return knexBuilder[knexMethod](column, value);
-      }
-    }
-
-    jsonApi.warnIfNotPostgres(knex);
-    const args = this.getKnexArgs(builder);
-
-    const rawArgs = jsonApi.whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams(
-      args[0],
-      this.opt.operator,
-      args[1],
-      this.opt.prefix,
-    );
-
-    if (this.opt.bool === 'or') {
-      knexBuilder = knexBuilder.orWhereRaw.apply(knexBuilder, rawArgs);
-    } else {
-      knexBuilder = knexBuilder.whereRaw.apply(knexBuilder, rawArgs);
-    }
-
-    return knexBuilder;
-  }
-
-  // Only the simple form with a plain column and a plain object or array value
-  // can be passed on to knex, as knex doesn't understand field expressions.
-  canDelegateToKnex(knexBuilder) {
-    const [column, value] = this.args;
-
-    return (
-      !!this.opt.knexMethod &&
-      isFunction(knexBuilder[this.opt.knexMethod]) &&
-      isString(column) &&
-      parseFieldExpression(column).access.length === 0 &&
-      (isPlainObject(value) || Array.isArray(value))
-    );
-  }
-}
-
-module.exports = {
-  WhereJsonPostgresOperation,
-};