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

package/lib/queryBuilder/operations/UpdateOperation.js

@@ -0,0 +1,155 @@
+'use strict';
+
+const { ref } = require('../../queryBuilder/ReferenceBuilder');
+const { isEmpty } = require('../../utils/objectUtils');
+const { isKnexRaw, isKnexQueryBuilder } = require('../../utils/knexUtils');
+const { toPgJsonPathLiteral, getJsonDialect } = require('../../utils/postgresJsonPath');
+const { toMySqlJsonPath } = require('../../utils/mysqlJsonPath');
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+const { StaticHookArguments } = require('../StaticHookArguments');
+
+class UpdateOperation extends QueryBuilderOperation {
+  constructor(name, opt) {
+    super(name, opt);
+
+    this.model = null;
+    this.modelOptions = Object.assign({}, this.opt.modelOptions || {});
+  }
+
+  onAdd(builder, args) {
+    const json = args[0];
+    const modelClass = builder.modelClass();
+
+    this.model = modelClass.ensureModel(json, this.modelOptions);
+    return true;
+  }
+
+  async onBefore2(builder, result) {
+    await callBeforeUpdate(builder, this.model, this.modelOptions);
+    return result;
+  }
+
+  onBefore3(builder) {
+    const row = this.model.$toDatabaseJson(builder);
+
+    if (isEmpty(row)) {
+      // Resolve the query if there is nothing to update.
+      builder.resolve(0);
+    }
+  }
+
+  onBuildKnex(knexBuilder, builder) {
+    const json = this.model.$toDatabaseJson(builder);
+    const convertedJson = convertFieldExpressionsToRaw(builder, this.model, json);
+
+    return knexBuilder.update(convertedJson);
+  }
+
+  onAfter2(builder, numUpdated) {
+    return callAfterUpdate(builder, this.model, this.modelOptions, numUpdated);
+  }
+
+  toFindOperation() {
+    return null;
+  }
+
+  clone() {
+    const clone = super.clone();
+    clone.model = this.model;
+    return clone;
+  }
+}
+
+async function callBeforeUpdate(builder, model, modelOptions) {
+  await callInstanceBeforeUpdate(builder, model, modelOptions);
+  return callStaticBeforeUpdate(builder);
+}
+
+function callInstanceBeforeUpdate(builder, model, modelOptions) {
+  return model.$beforeUpdate(modelOptions, builder.context());
+}
+
+function callStaticBeforeUpdate(builder) {
+  const args = StaticHookArguments.create({ builder });
+  return builder.modelClass().beforeUpdate(args);
+}
+
+async function callAfterUpdate(builder, model, modelOptions, result) {
+  await callInstanceAfterUpdate(builder, model, modelOptions);
+  return callStaticAfterUpdate(builder, result);
+}
+
+function callInstanceAfterUpdate(builder, model, modelOptions) {
+  return model.$afterUpdate(modelOptions, builder.context());
+}
+
+async function callStaticAfterUpdate(builder, result) {
+  const args = StaticHookArguments.create({ builder, result });
+  const maybeResult = await builder.modelClass().afterUpdate(args);
+
+  if (maybeResult === undefined) {
+    return result;
+  } else {
+    return maybeResult;
+  }
+}
+
+function convertFieldExpressionsToRaw(builder, model, json) {
+  const knex = builder.knex();
+  const convertedJson = {};
+
+  for (const key of Object.keys(json)) {
+    let val = json[key];
+
+    if (key.indexOf(':') > -1) {
+      // 'col:attr' : ref('other:lol') is transformed to
+      // "col" : raw(`jsonb_set(COALESCE("col", '{}'), '{attr}', to_jsonb("other"#>'{lol}'), true)`)
+      // on postgres and to
+      // `col` : raw("JSON_SET(COALESCE(`col`, JSON_OBJECT()), '$.\"attr\"', JSON_EXTRACT(`other`, '$.\"lol\"'))")
+      // on mysql. A NULL column is treated as an empty object (or array).
+
+      const parsed = ref(key);
+      const access = parsed.parsedExpr.access;
+      const isSqlValue = isKnexQueryBuilder(val) || isKnexRaw(val);
+      // When the column is set by an earlier key, that expression is used instead.
+      const target = convertedJson[parsed.column] || parsed.column;
+      const isFirstSet = !convertedJson[parsed.column];
+
+      if (!isSqlValue) {
+        val = JSON.stringify(val);
+      }
+
+      if (getJsonDialect(knex, key) === 'mysql') {
+        const empty = access[0].type === 'array' ? 'JSON_ARRAY()' : 'JSON_OBJECT()';
+        const column = isFirstSet ? `COALESCE(??, ${empty})` : '??';
+        const value = isSqlValue ? '?' : 'CAST(? AS JSON)';
+
+        convertedJson[parsed.column] = knex.raw(`JSON_SET(${column}, ?, ${value})`, [
+          target,
+          toMySqlJsonPath(access),
+          val,
+        ]);
+      } else {
+        const empty = access[0].type === 'array' ? `'[]'::jsonb` : `'{}'::jsonb`;
+        const column = isFirstSet ? `COALESCE(??, ${empty})` : '??';
+        const value = isSqlValue ? 'to_jsonb(?)' : '?';
+
+        convertedJson[parsed.column] = knex.raw(
+          `jsonb_set(${column}, ${toPgJsonPathLiteral(access)}, ${value}, true)`,
+          [target, val],
+        );
+      }
+
+      delete model[key];
+    } else {
+      convertedJson[key] = val;
+    }
+  }
+
+  return convertedJson;
+}
+
+module.exports = {
+  UpdateOperation,
+  convertFieldExpressionsToRaw,
+};

package/lib/queryBuilder/operations/UpsertGraphAndFetchOperation.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const { DelegateOperation } = require('./DelegateOperation');
+const { UpsertGraphOperation } = require('./UpsertGraphOperation');
+const { RelationExpression } = require('../RelationExpression');
+
+class UpsertGraphAndFetchOperation extends DelegateOperation {
+  constructor(name, opt) {
+    super(name, opt);
+
+    if (!this.delegate.is(UpsertGraphOperation)) {
+      throw new Error('Invalid delegate');
+    }
+  }
+
+  get models() {
+    return this.delegate.models;
+  }
+
+  get isArray() {
+    return this.delegate.isArray;
+  }
+
+  async onAfter3(builder) {
+    if (this.models.length === 0) {
+      return this.isArray ? [] : null;
+    }
+
+    const eager = RelationExpression.fromModelGraph(this.models);
+    const modelClass = this.models[0].constructor;
+    const ids = this.models.map((model) => model.$id());
+
+    const models = await modelClass
+      .query()
+      .childQueryOf(builder)
+      .findByIds(ids)
+      .withGraphFetched(eager);
+
+    return this.isArray ? models : models[0] || null;
+  }
+}
+
+module.exports = {
+  UpsertGraphAndFetchOperation,
+};

package/lib/queryBuilder/operations/UpsertGraphOperation.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+const { GraphUpsert } = require('../graph/GraphUpsert');
+const { RelationFindOperation } = require('../../relations/RelationFindOperation');
+
+class UpsertGraphOperation extends QueryBuilderOperation {
+  constructor(name, opt) {
+    super(
+      name,
+      Object.assign({}, opt, {
+        upsertOptions: {},
+      }),
+    );
+
+    this.upsertOptions = opt.upsertOptions || {};
+    this.upsert = null;
+  }
+
+  get models() {
+    return this.upsert.objects;
+  }
+
+  get isArray() {
+    return this.upsert.isArray;
+  }
+
+  onAdd(builder, args) {
+    const [objects] = args;
+
+    this.upsert = new GraphUpsert({
+      objects,
+      rootModelClass: builder.modelClass(),
+      upsertOptions: this.upsertOptions,
+    });
+
+    // Never execute this builder.
+    builder.resolve([]);
+
+    return true;
+  }
+
+  onAfter1(builder) {
+    if (hasOtherSqlModifyingQueryBuilderCalls(builder)) {
+      throw new Error(
+        'upsertGraph query should contain no other query builder calls like `findById`, `where` or `$relatedQuery` that would affect the SQL. They have no effect.',
+      );
+    }
+
+    return this.upsert.run(builder);
+  }
+
+  clone() {
+    const clone = super.clone();
+    clone.upsert = this.upsert;
+    return clone;
+  }
+}
+
+function hasOtherSqlModifyingQueryBuilderCalls(builder) {
+  return builder.has(/where/) || builder.has(RelationFindOperation);
+}
+
+module.exports = {
+  UpsertGraphOperation,
+};

package/lib/queryBuilder/operations/WhereCompositeOperation.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const { ObjectionToKnexConvertingOperation } = require('./ObjectionToKnexConvertingOperation');
+const { asSingle } = require('../../utils/objectUtils');
+
+class WhereCompositeOperation extends ObjectionToKnexConvertingOperation {
+  onBuildKnex(knexBuilder, builder) {
+    const args = this.getKnexArgs(builder);
+
+    if (args.length === 2) {
+      // Convert whereComposite('foo', 1) into whereComposite('foo', '=', 1)
+      args.splice(1, 0, '=');
+    } else if (args.length !== 3) {
+      throw new Error(`invalid number of arguments ${args.length}`);
+    }
+
+    return knexBuilder.where(...buildWhereArgs(...args));
+  }
+}
+
+function buildWhereArgs(cols, op, values) {
+  if (isNormalWhere(cols, values)) {
+    return buildNormalWhereArgs(cols, op, values);
+  } else if (isCompositeWhere(cols, values)) {
+    return buildCompositeWhereArgs(cols, op, values);
+  } else {
+    throw new Error(`both cols and values must have same dimensions`);
+  }
+}
+
+function isNormalWhere(cols, values) {
+  return (
+    (!Array.isArray(cols) || cols.length === 1) && (!Array.isArray(values) || values.length === 1)
+  );
+}
+
+function buildNormalWhereArgs(cols, op, values) {
+  return [asSingle(cols), op, asSingle(values)];
+}
+
+function isCompositeWhere(cols, values) {
+  return Array.isArray(cols) && Array.isArray(values) && cols.length === values.length;
+}
+
+function buildCompositeWhereArgs(cols, op, values) {
+  return [
+    (builder) => {
+      for (let i = 0, l = cols.length; i < l; ++i) {
+        builder.where(cols[i], op, values[i]);
+      }
+    },
+  ];
+}
+
+module.exports = {
+  WhereCompositeOperation,
+};

package/lib/queryBuilder/operations/WhereInOperation.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const { ObjectionToKnexConvertingOperation } = require('./ObjectionToKnexConvertingOperation');
+const { isKnexRaw } = require('../../utils/knexUtils');
+
+// `whereIn`, `whereNotIn`, `onIn` etc. knex compiles the values before the column,
+// so the bindings of a raw column (like `ref('data:a').castInt()` on MySQL or
+// `fn.lower(ref('a'))`) end up after the values and the query uses the wrong
+// bindings. In that case the condition is built as raw sql with the bindings in
+// the right order.
+class WhereInOperation extends ObjectionToKnexConvertingOperation {
+  onBuildKnex(knexBuilder, builder) {
+    const args = this.getKnexArgs(builder);
+    const [column, values] = args;
+
+    if (args.length !== 2 || !hasBindings(column) || isEmptyArray(values)) {
+      return knexBuilder[this.name].apply(knexBuilder, args);
+    }
+
+    const knex = builder.knex();
+    const not = this.opt.not ? 'not ' : '';
+    let sql;
+    let bindings;
+
+    if (Array.isArray(values)) {
+      sql = `? ${not}in (${values.map(() => '?').join(', ')})`;
+      bindings = [column, ...values];
+    } else {
+      // A subquery.
+      sql = `? ${not}in ?`;
+      bindings = [column, values];
+    }
+
+    return knexBuilder[this.opt.rawMethod](knex.raw(sql, bindings));
+  }
+}
+
+function hasBindings(column) {
+  return isKnexRaw(column) && Array.isArray(column.bindings) && column.bindings.length > 0;
+}
+
+function isEmptyArray(values) {
+  return Array.isArray(values) && values.length === 0;
+}
+
+module.exports = {
+  WhereInOperation,
+};

package/lib/queryBuilder/operations/eager/EagerOperation.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const { QueryBuilderOperation } = require('../QueryBuilderOperation');
+const { RelationExpression } = require('../../RelationExpression');
+
+class EagerOperation extends QueryBuilderOperation {
+  constructor(name, opt) {
+    super(name, opt);
+
+    this.expression = RelationExpression.create();
+    this.modifiersAtPath = [];
+    this.graphOptions = this.opt.defaultGraphOptions;
+  }
+
+  buildFinalExpression() {
+    const expression = this.expression.clone();
+
+    this.modifiersAtPath.forEach((modifier, i) => {
+      const modifierName = getModifierName(i);
+
+      expression.expressionsAtPath(modifier.path).forEach((expr) => {
+        expr.node.$modify.push(modifierName);
+      });
+    });
+
+    return expression;
+  }
+
+  buildFinalModifiers(builder) {
+    // `modifiers()` returns a clone so we can modify it.
+    const modifiers = builder.modifiers();
+
+    this.modifiersAtPath.forEach((modifier, i) => {
+      const modifierName = getModifierName(i);
+
+      modifiers[modifierName] = modifier.modifier;
+    });
+
+    return modifiers;
+  }
+
+  cloneFrom(eagerOp) {
+    this.expression = eagerOp.expression.clone();
+    this.modifiersAtPath = eagerOp.modifiersAtPath.slice();
+    this.graphOptions = Object.assign({}, eagerOp.graphOptions);
+  }
+
+  clone() {
+    const clone = super.clone();
+    clone.cloneFrom(this);
+    return clone;
+  }
+}
+
+function getModifierName(index) {
+  return `_f${index}_`;
+}
+
+module.exports = {
+  EagerOperation,
+};

package/lib/queryBuilder/operations/eager/JoinEagerOperation.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const { EagerOperation } = require('./EagerOperation');
+const { RelationJoiner } = require('../../join/RelationJoiner');
+
+class JoinEagerOperation extends EagerOperation {
+  constructor(name, opt) {
+    super(name, opt);
+    this.joiner = null;
+  }
+
+  onAdd(builder) {
+    builder.findOptions({ callAfterFindDeeply: true });
+
+    this.joiner = new RelationJoiner({
+      modelClass: builder.modelClass(),
+    });
+
+    return true;
+  }
+
+  onBefore3(builder) {
+    return this.joiner
+      .setExpression(this.buildFinalExpression())
+      .setModifiers(this.buildFinalModifiers(builder))
+      .setOptions(this.graphOptions)
+      .fetchColumnInfo(builder);
+  }
+
+  onBuild(builder) {
+    this.joiner
+      .setExpression(this.buildFinalExpression())
+      .setModifiers(this.buildFinalModifiers(builder))
+      .setOptions(this.graphOptions)
+      .build(builder);
+  }
+
+  onRawResult(builder, rows) {
+    return this.joiner.parseResult(builder, rows);
+  }
+
+  clone() {
+    const clone = super.clone();
+    clone.joiner = this.joiner;
+    return clone;
+  }
+}
+
+module.exports = {
+  JoinEagerOperation,
+};

package/lib/queryBuilder/operations/eager/NaiveEagerOperation.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const { WhereInEagerOperation } = require('./WhereInEagerOperation');
+
+class NaiveEagerOperation extends WhereInEagerOperation {
+  batchSize() {
+    return 1;
+  }
+}
+
+module.exports = {
+  NaiveEagerOperation,
+};