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

package/lib/relations/manyToMany/insert/ManyToManyInsertOperation.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const { RelationInsertOperation } = require('../../RelationInsertOperation');
+const { ManyToManyRelateOperation } = require('../relate/ManyToManyRelateOperation');
+
+class ManyToManyInsertOperation extends RelationInsertOperation {
+  onAdd(builder, args) {
+    const retVal = super.onAdd(builder, args);
+
+    // Omit extra properties so that we don't try to insert
+    // them to the related table. We don't actually remove them
+    // from the objects, but simply mark them to be removed
+    // from the inserted row.
+    this.relation.omitExtraProps(this.models);
+
+    return retVal;
+  }
+
+  async onAfter1(builder, ret) {
+    const inserted = await super.onAfter1(builder, ret);
+
+    const relateOp = new ManyToManyRelateOperation('relate', {
+      dontCopyReturning: true,
+      dontCopyOnConflict: true,
+      relation: this.relation,
+      owner: this.owner,
+    });
+
+    const modelsToRelate = inserted.filter((it) => {
+      return this.relation.relatedProp.hasProps(it);
+    });
+
+    if (this.assignResultToOwner && this.owner.isModels) {
+      for (const owner of this.owner.modelArray) {
+        owner.$appendRelated(this.relation, inserted);
+      }
+    }
+
+    if (modelsToRelate.length === 0) {
+      return inserted;
+    }
+
+    relateOp.onAdd(builder, [modelsToRelate]);
+    await relateOp.queryExecutor(builder);
+
+    return inserted;
+  }
+}
+
+module.exports = {
+  ManyToManyInsertOperation,
+};

package/lib/relations/manyToMany/relate/ManyToManyRelateOperation.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const { isPostgres } = require('../../../utils/knexUtils');
+const { normalizeIds } = require('../../../utils/normalizeIds');
+const { RelateOperation } = require('../../../queryBuilder/operations/RelateOperation');
+
+class ManyToManyRelateOperation extends RelateOperation {
+  onAdd(builder, args) {
+    this.input = args[0];
+    this.ids = normalizeIds(args[0], this.relation.relatedProp);
+
+    assertOwnerIsSingleItem(builder, this.owner, this.relation);
+    return true;
+  }
+
+  queryExecutor(builder) {
+    const joinModelClass = this.relation.getJoinModelClass(builder.knex());
+    const ownerValues = this.owner.getSplitProps(builder, this.relation);
+    const joinModels = [];
+
+    for (const ownerValue of ownerValues) {
+      for (const relatedValue of this.ids) {
+        joinModels.push(
+          joinModelClass.fromJson(this.relation.createJoinModel(ownerValue, relatedValue)),
+        );
+      }
+    }
+
+    return joinModelClass
+      .query()
+      .childQueryOf(builder)
+      .modify((query) => {
+        if (!this.opt.dontCopyReturning) {
+          query.copyFrom(builder, /returning/);
+        }
+
+        if (!this.opt.dontCopyOnConflict) {
+          query.copyFrom(builder, /onConflict|ignore|merge/);
+        }
+      })
+      .runBefore((_, builder) => {
+        return this.relation.executeJoinTableBeforeInsert(joinModels, builder.context(), null);
+      })
+      .insert(joinModels)
+      .runAfter((models) => {
+        return Array.isArray(models) ? models.length : 1;
+      });
+  }
+}
+
+function assertOwnerIsSingleItem(builder, owner, relation) {
+  const { isModels, isIdentifiers, isQueryBuilder } = owner;
+  const { ownerProp } = relation;
+
+  const singleModel = isModels && owner.modelArray.length === 1;
+  const singleId = isIdentifiers && owner.getNormalizedIdentifiers(ownerProp).length === 1;
+
+  if (isPostgres(builder.unsafeKnex())) {
+    if (!isModels && !isIdentifiers && !isQueryBuilder) {
+      throw new Error(
+        'Parent must be a list of identifiers or a list of models when relating a ManyToManyRelation',
+      );
+    }
+  } else {
+    if (!singleModel && !singleId && !isQueryBuilder) {
+      throw new Error(
+        [
+          'Can only relate items for one parent at a time in case of ManyToManyRelation.',
+          'Otherwise multiple insert queries would need to be created.',
+
+          'If you need to relate items for multiple parents, simply loop through them.',
+          `That's the most performant way.`,
+        ].join(' '),
+      );
+    }
+  }
+}
+
+module.exports = {
+  ManyToManyRelateOperation,
+};

package/lib/relations/manyToMany/unrelate/ManyToManyUnrelateOperation.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const { ManyToManyUnrelateOperationBase } = require('./ManyToManyUnrelateOperationBase');
+const { ManyToManyModifyMixin } = require('../ManyToManyModifyMixin');
+
+class ManyToManyUnrelateOperation extends ManyToManyModifyMixin(ManyToManyUnrelateOperationBase) {
+  get modifyMainQuery() {
+    return false;
+  }
+}
+
+module.exports = {
+  ManyToManyUnrelateOperation,
+};

package/lib/relations/manyToMany/unrelate/ManyToManyUnrelateOperationBase.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const { withWhereScope } = require('../../../queryBuilder/whereScopes');
+const { UnrelateOperation } = require('../../../queryBuilder/operations/UnrelateOperation');
+
+class ManyToManyUnrelateOperationBase extends UnrelateOperation {
+  queryExecutor(builder) {
+    const unrelateQuery = this.relation
+      .getJoinModelClass(builder.knex())
+      .query()
+      .childQueryOf(builder)
+      .delete();
+
+    withWhereScope(unrelateQuery, () => {
+      this.applyModifyFilterForJoinTable(unrelateQuery);
+    });
+
+    return unrelateQuery.modify(this.relation.joinTableModify);
+  }
+
+  /* istanbul ignore next */
+  applyModifyFilterForRelatedTable(builder) {
+    throw new Error('not implemented');
+  }
+
+  /* istanbul ignore next */
+  applyModifyFilterForJoinTable(builder) {
+    throw new Error('not implemented');
+  }
+}
+
+module.exports = {
+  ManyToManyUnrelateOperationBase,
+};

package/lib/relations/manyToMany/unrelate/ManyToManyUnrelateSqliteOperation.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { ManyToManyUnrelateOperationBase } = require('./ManyToManyUnrelateOperationBase');
+const { ManyToManySqliteModifyMixin } = require('../ManyToManySqliteModifyMixin');
+
+class ManyToManyUnrelateSqliteOperation extends ManyToManySqliteModifyMixin(
+  ManyToManyUnrelateOperationBase,
+) {
+  get modifyMainQuery() {
+    return false;
+  }
+}
+
+module.exports = {
+  ManyToManyUnrelateSqliteOperation,
+};

package/lib/relations/manyToMany/update/ManyToManyUpdateOperation.js

@@ -0,0 +1,10 @@
+'use strict';
+
+const { ManyToManyUpdateOperationBase } = require('./ManyToManyUpdateOperationBase');
+const { ManyToManyModifyMixin } = require('../ManyToManyModifyMixin');
+
+class ManyToManyUpdateOperation extends ManyToManyModifyMixin(ManyToManyUpdateOperationBase) {}
+
+module.exports = {
+  ManyToManyUpdateOperation,
+};

package/lib/relations/manyToMany/update/ManyToManyUpdateOperationBase.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const { withWhereScope } = require('../../../queryBuilder/whereScopes');
+const { UpdateOperation } = require('../../../queryBuilder/operations/UpdateOperation');
+
+class ManyToManyUpdateOperationBase extends UpdateOperation {
+  constructor(name, opt) {
+    super(name, opt);
+
+    this.relation = opt.relation;
+    this.owner = opt.owner;
+
+    this.hasExtraProps = false;
+    this.joinTablePatch = {};
+    this.joinTablePatchFilterQuery = null;
+  }
+
+  onAdd(builder, args) {
+    const obj = args[0];
+
+    // Copy all extra properties to the `joinTablePatch` object.
+    for (const extra of this.relation.joinTableExtras) {
+      if (extra.aliasProp in obj) {
+        this.hasExtraProps = true;
+        this.joinTablePatch[extra.joinTableProp] = obj[extra.aliasProp];
+      }
+    }
+
+    const res = super.onAdd(builder, args);
+
+    if (this.hasExtraProps) {
+      // Make sure we don't try to insert the extra properties
+      // to the target table.
+      this.relation.omitExtraProps([this.model]);
+    }
+
+    return res;
+  }
+
+  async onAfter1(builder, result) {
+    if (this.hasExtraProps) {
+      const joinTableUpdateQuery = this.relation
+        .getJoinModelClass(builder.knex())
+        .query()
+        .childQueryOf(builder)
+        .patch(this.joinTablePatch);
+
+      withWhereScope(joinTableUpdateQuery, () => {
+        this.applyModifyFilterForJoinTable(joinTableUpdateQuery);
+      });
+
+      await joinTableUpdateQuery.modify(this.relation.joinTableModify);
+      return result;
+    } else {
+      return result;
+    }
+  }
+
+  /* istanbul ignore next */
+  applyModifyFilterForRelatedTable(builder) {
+    throw new Error('not implemented');
+  }
+
+  /* istanbul ignore next */
+  applyModifyFilterForJoinTable(builder) {
+    throw new Error('not implemented');
+  }
+
+  clone() {
+    const clone = super.clone();
+
+    clone.hasExtraProps = this.hasExtraProps;
+    clone.joinTablePatch = this.joinTablePatch;
+    clone.joinTablePatchFilterQuery = this.joinTablePatchFilterQuery;
+
+    return clone;
+  }
+}
+
+module.exports = {
+  ManyToManyUpdateOperationBase,
+};

package/lib/relations/manyToMany/update/ManyToManyUpdateSqliteOperation.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const { ManyToManyUpdateOperationBase } = require('./ManyToManyUpdateOperationBase');
+const { ManyToManySqliteModifyMixin } = require('../ManyToManySqliteModifyMixin');
+
+class ManyToManyUpdateSqliteOperation extends ManyToManySqliteModifyMixin(
+  ManyToManyUpdateOperationBase,
+) {}
+
+module.exports = {
+  ManyToManyUpdateSqliteOperation,
+};

package/lib/transaction.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const promiseUtils = require('./utils/promiseUtils');
+const { isFunction } = require('./utils/objectUtils');
+
+function transaction() {
+  // There must be at least one model class and the callback.
+  if (arguments.length < 2) {
+    return Promise.reject(
+      new Error(
+        'objection.transaction: provide at least one Model class to bind to the transaction or a knex instance',
+      ),
+    );
+  }
+
+  let args = Array.from(arguments);
+
+  if (!isModelClass(args[0]) && isFunction(args[0].transaction)) {
+    let knex = args[0];
+    args = args.slice(1);
+
+    return knex.transaction.apply(knex, args);
+  } else {
+    // The last argument should be the callback and all other Model subclasses.
+    let callback = args[args.length - 1];
+    let modelClasses = args.slice(0, args.length - 1);
+    let i;
+
+    for (i = 0; i < modelClasses.length; ++i) {
+      if (!isModelClass(modelClasses[i])) {
+        return Promise.reject(
+          new Error('objection.transaction: all but the last argument should be Model subclasses'),
+        );
+      }
+    }
+
+    let knex = modelClasses[0].knex();
+    for (i = 0; i < modelClasses.length; ++i) {
+      if (modelClasses[i].knex() !== knex) {
+        return Promise.reject(
+          new Error(
+            'objection.transaction: all Model subclasses must be bound to the same database',
+          ),
+        );
+      }
+    }
+
+    return knex.transaction((trx) => {
+      let args = new Array(modelClasses.length + 1);
+
+      for (let i = 0; i < modelClasses.length; ++i) {
+        args[i] = modelClasses[i].bindTransaction(trx);
+      }
+
+      args[args.length - 1] = trx;
+
+      return promiseUtils.try(() => {
+        return callback.apply(trx, args);
+      });
+    });
+  }
+}
+
+transaction.start = function (modelClassOrKnex) {
+  let knex = modelClassOrKnex;
+
+  if (isModelClass(modelClassOrKnex)) {
+    knex = modelClassOrKnex.knex();
+  }
+
+  if (!knex || !isFunction(knex.transaction)) {
+    return Promise.reject(
+      new Error(
+        'objection.transaction.start: first argument must be a model class or a knex instance',
+      ),
+    );
+  }
+
+  return new Promise((resolve, reject) => {
+    knex
+      .transaction((trx) => {
+        resolve(trx);
+      })
+      .catch((err) => {
+        reject(err);
+      });
+  });
+};
+
+function isModelClass(maybeModel) {
+  return isFunction(maybeModel) && maybeModel.isObjectionModelClass;
+}
+
+module.exports = {
+  transaction,
+};

package/lib/utils/assert.js

@@ -0,0 +1,25 @@
+'use strict';
+
+function assertHasId(model) {
+  if (!model.$hasId()) {
+    const modelClass = model.constructor;
+    const ids = modelClass.getIdColumnArray().join(', ');
+
+    throw new Error(
+      `one of the identifier columns [${ids}] is null or undefined. Have you specified the correct identifier column for the model '${modelClass.name}' using the 'idColumn' property?`,
+    );
+  }
+}
+
+function assertIdNotUndefined(id, message) {
+  if (Array.isArray(id)) {
+    id.forEach((id) => assertIdNotUndefined(id, message));
+  } else if (id === undefined) {
+    throw Error(message);
+  }
+}
+
+module.exports = {
+  assertHasId,
+  assertIdNotUndefined,
+};

package/lib/utils/buildUtils.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const { isObject, isFunction } = require('./objectUtils');
+
+function buildArg(arg, builder) {
+  if (!isObject(arg)) {
+    return arg;
+  }
+
+  if (isFunction(arg.toKnexRaw)) {
+    return arg.toKnexRaw(builder);
+  } else if (arg.isObjectionQueryBuilderBase === true) {
+    return arg.subqueryOf(builder).toKnexQuery();
+  } else {
+    return arg;
+  }
+}
+
+module.exports = {
+  buildArg,
+};

package/lib/utils/classUtils.js

@@ -0,0 +1,13 @@
+'use strict';
+
+function inherit(Constructor, BaseConstructor) {
+  Constructor.prototype = Object.create(BaseConstructor.prototype);
+  Constructor.prototype.constructor = BaseConstructor;
+  Object.setPrototypeOf(Constructor, BaseConstructor);
+
+  return Constructor;
+}
+
+module.exports = {
+  inherit,
+};