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

package/lib/queryBuilder/operations/InstanceUpdateOperation.js

@@ -1,59 +1,45 @@
 'use strict';
-
 const { withWhereScope } = require('../whereScopes');
 const { UpdateOperation } = require('./UpdateOperation');
 const { InstanceFindOperation } = require('./InstanceFindOperation');
 const { assertHasId } = require('../../utils/assert');
 const { isObject } = require('../../utils/objectUtils');
-
 class InstanceUpdateOperation extends UpdateOperation {
-  constructor(name, opt) {
-    super(name, opt);
-
-    this.instance = opt.instance;
-    this.modelOptions.old = opt.instance;
-  }
-
-  onAdd(builder, args) {
-    const retVal = super.onAdd(builder, args);
-
-    if (!this.model) {
-      this.model = this.instance;
+    constructor(name, opt) {
+        super(name, opt);
+        this.instance = opt.instance;
+        this.modelOptions.old = opt.instance;
     }
-
-    return retVal;
-  }
-
-  onBuild(builder) {
-    super.onBuild(builder);
-
-    assertHasId(this.instance);
-    withWhereScope(builder, () => builder.findById(this.instance.$id()));
-  }
-
-  async onAfter2(builder, result) {
-    // The result may be an object if `returning` was used.
-    if (Array.isArray(result)) {
-      result = result[0];
+    onAdd(builder, args) {
+        const retVal = super.onAdd(builder, args);
+        if (!this.model) {
+            this.model = this.instance;
+        }
+        return retVal;
     }
-
-    result = await super.onAfter2(builder, result);
-    this.instance.$set(this.model);
-
-    if (isObject(result)) {
-      this.instance.$set(result);
+    onBuild(builder) {
+        super.onBuild(builder);
+        assertHasId(this.instance);
+        withWhereScope(builder, () => builder.findById(this.instance.$id()));
+    }
+    async onAfter2(builder, result) {
+        // The result may be an object if `returning` was used.
+        if (Array.isArray(result)) {
+            result = result[0];
+        }
+        result = await super.onAfter2(builder, result);
+        this.instance.$set(this.model);
+        if (isObject(result)) {
+            this.instance.$set(result);
+        }
+        return result;
+    }
+    toFindOperation() {
+        return new InstanceFindOperation('find', {
+            instance: this.instance,
+        });
     }
-
-    return result;
-  }
-
-  toFindOperation() {
-    return new InstanceFindOperation('find', {
-      instance: this.instance,
-    });
-  }
 }
-
 module.exports = {
-  InstanceUpdateOperation,
+    InstanceUpdateOperation,
 };

package/lib/queryBuilder/operations/JoinRelatedOperation.js

@@ -1,103 +1,83 @@
 'use strict';
-
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
 const { RelationExpression } = require('../RelationExpression');
 const { RelationJoiner } = require('../join/RelationJoiner');
 const { isString } = require('../../utils/objectUtils');
-
 class JoinRelatedOperation extends QueryBuilderOperation {
-  constructor(name, opt) {
-    super(name, opt);
-    this.calls = [];
-  }
-
-  get joinOperation() {
-    return this.opt.joinOperation;
-  }
-
-  addCall(call) {
-    this.calls.push(call);
-  }
-
-  onBuild(builder) {
-    const modelClass = builder.modelClass();
-    const joinOperation = this.joinOperation;
-    let mergedExpr = RelationExpression.create();
-
-    for (const call of this.calls) {
-      const expr = RelationExpression.create(call.expression).toPojo();
-      const childNames = expr.$childNames;
-      const options = call.options || {};
-
-      if (childNames.length === 1) {
-        applyAlias(expr, modelClass, builder, options);
-      }
-
-      if (options.aliases) {
-        applyAliases(expr, modelClass, options);
-      }
-
-      mergedExpr = mergedExpr.merge(expr);
+    constructor(name, opt) {
+        super(name, opt);
+        this.calls = [];
+    }
+    get joinOperation() {
+        return this.opt.joinOperation;
+    }
+    addCall(call) {
+        this.calls.push(call);
+    }
+    onBuild(builder) {
+        const modelClass = builder.modelClass();
+        const joinOperation = this.joinOperation;
+        let mergedExpr = RelationExpression.create();
+        for (const call of this.calls) {
+            const expr = RelationExpression.create(call.expression).toPojo();
+            const childNames = expr.$childNames;
+            const options = call.options || {};
+            if (childNames.length === 1) {
+                applyAlias(expr, modelClass, builder, options);
+            }
+            if (options.aliases) {
+                applyAliases(expr, modelClass, options);
+            }
+            mergedExpr = mergedExpr.merge(expr);
+        }
+        const joiner = new RelationJoiner({
+            modelClass,
+        });
+        joiner.setOptions({ joinOperation });
+        joiner.setExpression(mergedExpr);
+        joiner.setModifiers(builder.modifiers());
+        joiner.build(builder, false);
+    }
+    clone() {
+        const clone = super.clone();
+        clone.calls = this.calls.slice();
+        return clone;
     }
-
-    const joiner = new RelationJoiner({
-      modelClass,
-    });
-
-    joiner.setOptions({ joinOperation });
-    joiner.setExpression(mergedExpr);
-    joiner.setModifiers(builder.modifiers());
-    joiner.build(builder, false);
-  }
-
-  clone() {
-    const clone = super.clone();
-    clone.calls = this.calls.slice();
-    return clone;
-  }
 }
-
 function applyAlias(expr, modelClass, builder, options) {
-  const childNames = expr.$childNames;
-  const childName = childNames[0];
-  const childExpr = expr[childName];
-  const relation = modelClass.getRelation(childExpr.$relation);
-
-  let alias = childName;
-
-  if (options.alias === false) {
-    alias = builder.tableRefFor(relation.relatedModelClass);
-  } else if (isString(options.alias)) {
-    alias = options.alias;
-  }
-
-  if (childName !== alias) {
-    renameRelationExpressionNode(expr, childName, alias);
-  }
-}
-
-function applyAliases(expr, modelClass, options) {
-  for (const childName of expr.$childNames) {
+    const childNames = expr.$childNames;
+    const childName = childNames[0];
     const childExpr = expr[childName];
     const relation = modelClass.getRelation(childExpr.$relation);
-    const alias = options.aliases[childExpr.$relation];
-
-    if (alias && alias !== childName) {
-      renameRelationExpressionNode(expr, childName, alias);
+    let alias = childName;
+    if (options.alias === false) {
+        alias = builder.tableRefFor(relation.relatedModelClass);
+    }
+    else if (isString(options.alias)) {
+        alias = options.alias;
+    }
+    if (childName !== alias) {
+        renameRelationExpressionNode(expr, childName, alias);
+    }
+}
+function applyAliases(expr, modelClass, options) {
+    for (const childName of expr.$childNames) {
+        const childExpr = expr[childName];
+        const relation = modelClass.getRelation(childExpr.$relation);
+        const alias = options.aliases[childExpr.$relation];
+        if (alias && alias !== childName) {
+            renameRelationExpressionNode(expr, childName, alias);
+        }
+        applyAliases(childExpr, relation.relatedModelClass, options);
     }
-
-    applyAliases(childExpr, relation.relatedModelClass, options);
-  }
 }
-
 function renameRelationExpressionNode(expr, oldName, newName) {
-  const childExpr = expr[oldName];
-  delete expr[oldName];
-  expr[newName] = childExpr;
-  childExpr.$name = newName;
-  expr.$childNames = expr.$childNames.map((it) => (it === oldName ? newName : it));
+    const childExpr = expr[oldName];
+    delete expr[oldName];
+    expr[newName] = childExpr;
+    childExpr.$name = newName;
+    expr.$childNames = expr.$childNames.map((it) => (it === oldName ? newName : it));
 }
-
 module.exports = {
-  JoinRelatedOperation,
+    JoinRelatedOperation,
 };

package/lib/queryBuilder/operations/KnexOperation.js

@@ -1,14 +1,11 @@
 'use strict';
-
 const { ObjectionToKnexConvertingOperation } = require('./ObjectionToKnexConvertingOperation');
-
 // An operation that simply calls the equivalent knex method.
 class KnexOperation extends ObjectionToKnexConvertingOperation {
-  onBuildKnex(knexBuilder, builder) {
-    return knexBuilder[this.name].apply(knexBuilder, this.getKnexArgs(builder));
-  }
+    onBuildKnex(knexBuilder, builder) {
+        return knexBuilder[this.name].apply(knexBuilder, this.getKnexArgs(builder));
+    }
 }
-
 module.exports = {
-  KnexOperation,
+    KnexOperation,
 };

package/lib/queryBuilder/operations/MergeOperation.js

@@ -1,56 +1,43 @@
 'use strict';
-
 const { isFunction, isEmpty, isObject } = require('../../utils/objectUtils');
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
 const { convertFieldExpressionsToRaw } = require('./UpdateOperation');
-
 class MergeOperation extends QueryBuilderOperation {
-  constructor(name, opt) {
-    super(name, opt);
-    this.model = null;
-    this.args = null;
-  }
-
-  onAdd(builder, args) {
-    this.args = args;
-
-    if (!isEmpty(args) && isObject(args[0]) && !Array.isArray(args[0])) {
-      const json = args[0];
-      const modelClass = builder.modelClass();
-
-      this.model = modelClass.ensureModel(json, { patch: true });
+    constructor(name, opt) {
+        super(name, opt);
+        this.model = null;
+        this.args = null;
     }
-
-    return true;
-  }
-
-  onBuildKnex(knexBuilder, builder) {
-    if (!isFunction(knexBuilder.merge)) {
-      throw new Error('merge method can only be chained right after onConflict method');
+    onAdd(builder, args) {
+        this.args = args;
+        if (!isEmpty(args) && isObject(args[0]) && !Array.isArray(args[0])) {
+            const json = args[0];
+            const modelClass = builder.modelClass();
+            this.model = modelClass.ensureModel(json, { patch: true });
+        }
+        return true;
     }
-
-    if (this.model) {
-      const json = this.model.$toDatabaseJson(builder);
-      const convertedJson = convertFieldExpressionsToRaw(builder, this.model, json);
-
-      return knexBuilder.merge(convertedJson);
+    onBuildKnex(knexBuilder, builder) {
+        if (!isFunction(knexBuilder.merge)) {
+            throw new Error('merge method can only be chained right after onConflict method');
+        }
+        if (this.model) {
+            const json = this.model.$toDatabaseJson(builder);
+            const convertedJson = convertFieldExpressionsToRaw(builder, this.model, json);
+            return knexBuilder.merge(convertedJson);
+        }
+        return knexBuilder.merge(...this.args);
+    }
+    toFindOperation() {
+        return null;
+    }
+    clone() {
+        const clone = super.clone();
+        clone.model = this.model;
+        clone.args = this.args;
+        return clone;
     }
-
-    return knexBuilder.merge(...this.args);
-  }
-
-  toFindOperation() {
-    return null;
-  }
-
-  clone() {
-    const clone = super.clone();
-    clone.model = this.model;
-    clone.args = this.args;
-    return clone;
-  }
 }
-
 module.exports = {
-  MergeOperation,
+    MergeOperation,
 };