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

package/lib/relations/manyToMany/ManyToManySqliteModifyMixin.js

@@ -1,36 +1,29 @@
 'use strict';
-
 const { ManyToManyModifyMixin } = require('./ManyToManyModifyMixin');
 const SQLITE_BUILTIN_ROW_ID = '_rowid_';
-
 // We need to override this mixin for sqlite because sqlite doesn't support
 // multi-column where in statements with subqueries. We need to use the
 // internal _rowid_ column instead.
 const ManyToManySqliteModifyMixin = (Operation) => {
-  return class extends ManyToManyModifyMixin(Operation) {
-    applyModifyFilterForRelatedTable(builder) {
-      const tableRef = builder.tableRefFor(this.relation.relatedModelClass);
-      const rowIdRef = `${tableRef}.${SQLITE_BUILTIN_ROW_ID}`;
-      const subquery = this.modifyFilterSubquery.clone().select(rowIdRef);
-
-      return builder.whereInComposite(rowIdRef, subquery);
-    }
-
-    applyModifyFilterForJoinTable(builder) {
-      const joinTableOwnerRefs = this.relation.joinTableOwnerProp.refs(builder);
-      const tableRef = builder.tableRefFor(this.relation.getJoinModelClass(builder));
-      const rowIdRef = `${tableRef}.${SQLITE_BUILTIN_ROW_ID}`;
-
-      const ownerValues = this.owner.getProps(this.relation);
-      const subquery = this.modifyFilterSubquery.clone().select(rowIdRef);
-
-      return builder
-        .whereInComposite(rowIdRef, subquery)
-        .whereInComposite(joinTableOwnerRefs, ownerValues);
-    }
-  };
+    return class extends ManyToManyModifyMixin(Operation) {
+        applyModifyFilterForRelatedTable(builder) {
+            const tableRef = builder.tableRefFor(this.relation.relatedModelClass);
+            const rowIdRef = `${tableRef}.${SQLITE_BUILTIN_ROW_ID}`;
+            const subquery = this.modifyFilterSubquery.clone().select(rowIdRef);
+            return builder.whereInComposite(rowIdRef, subquery);
+        }
+        applyModifyFilterForJoinTable(builder) {
+            const joinTableOwnerRefs = this.relation.joinTableOwnerProp.refs(builder);
+            const tableRef = builder.tableRefFor(this.relation.getJoinModelClass(builder));
+            const rowIdRef = `${tableRef}.${SQLITE_BUILTIN_ROW_ID}`;
+            const ownerValues = this.owner.getProps(this.relation);
+            const subquery = this.modifyFilterSubquery.clone().select(rowIdRef);
+            return builder
+                .whereInComposite(rowIdRef, subquery)
+                .whereInComposite(joinTableOwnerRefs, ownerValues);
+        }
+    };
 };
-
 module.exports = {
-  ManyToManySqliteModifyMixin,
+    ManyToManySqliteModifyMixin,
 };

package/lib/relations/manyToMany/delete/ManyToManyDeleteOperation.js

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

package/lib/relations/manyToMany/delete/ManyToManyDeleteOperationBase.js

@@ -1,26 +1,20 @@
 'use strict';
-
 const { DeleteOperation } = require('../../../queryBuilder/operations/DeleteOperation');
-
 class ManyToManyDeleteOperationBase extends DeleteOperation {
-  constructor(name, opt) {
-    super(name, opt);
-
-    this.relation = opt.relation;
-    this.owner = opt.owner;
-  }
-
-  /* istanbul ignore next */
-  applyModifyFilterForRelatedTable(builder) {
-    throw new Error('not implemented');
-  }
-
-  /* istanbul ignore next */
-  applyModifyFilterForJoinTable(builder) {
-    throw new Error('not implemented');
-  }
+    constructor(name, opt) {
+        super(name, opt);
+        this.relation = opt.relation;
+        this.owner = opt.owner;
+    }
+    /* istanbul ignore next */
+    applyModifyFilterForRelatedTable(builder) {
+        throw new Error('not implemented');
+    }
+    /* istanbul ignore next */
+    applyModifyFilterForJoinTable(builder) {
+        throw new Error('not implemented');
+    }
 }
-
 module.exports = {
-  ManyToManyDeleteOperationBase,
+    ManyToManyDeleteOperationBase,
 };

package/lib/relations/manyToMany/delete/ManyToManyDeleteSqliteOperation.js

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

package/lib/relations/manyToMany/find/ManyToManyFindOperation.js

@@ -1,105 +1,82 @@
 'use strict';
-
 const { RelationFindOperation } = require('../../RelationFindOperation');
 const { getTempColumn } = require('../../../utils/tmpColumnUtils');
-
 class ManyToManyFindOperation extends RelationFindOperation {
-  constructor(name, opt) {
-    super(name, opt);
-
-    this.ownerJoinColumnAlias = new Array(this.relation.joinTableOwnerProp.size);
-
-    for (let i = 0, l = this.ownerJoinColumnAlias.length; i < l; ++i) {
-      this.ownerJoinColumnAlias[i] = getTempColumn(i);
-    }
-  }
-
-  onBuild(builder) {
-    const relatedModelClass = this.relation.relatedModelClass;
-
-    this.maybeApplyAlias(builder);
-    this.relation.findQuery(builder, this.owner);
-
-    if (!builder.hasSelects()) {
-      const table = builder.tableRefFor(relatedModelClass);
-
-      // If the user hasn't specified a select clause, select the related model's columns.
-      // If we don't do this we also get the join table's columns.
-      builder.select(`${table}.*`);
-
-      // Also select all extra columns.
-      for (const extra of this.relation.joinTableExtras) {
-        const joinTable = builder.tableRefFor(this.relation.joinTable);
-        builder.select(`${joinTable}.${extra.joinTableCol} as ${extra.aliasCol}`);
-      }
-    }
-
-    if (this.assignResultToOwner && this.owner.isModels) {
-      this.selectMissingJoinColumns(builder);
+    constructor(name, opt) {
+        super(name, opt);
+        this.ownerJoinColumnAlias = new Array(this.relation.joinTableOwnerProp.size);
+        for (let i = 0, l = this.ownerJoinColumnAlias.length; i < l; ++i) {
+            this.ownerJoinColumnAlias[i] = getTempColumn(i);
+        }
     }
-  }
-
-  onAfter2(_, related) {
-    const isOneToOne = this.relation.isOneToOne();
-
-    if (this.assignResultToOwner && this.owner.isModels) {
-      const owners = this.owner.modelArray;
-      const ownerProp = this.relation.ownerProp;
-      const relatedByOwnerId = new Map();
-
-      for (let i = 0, l = related.length; i < l; ++i) {
-        const rel = related[i];
-        const key = rel.$propKey(this.ownerJoinColumnAlias);
-        let arr = relatedByOwnerId.get(key);
-
-        if (!arr) {
-          arr = [];
-          relatedByOwnerId.set(key, arr);
+    onBuild(builder) {
+        const relatedModelClass = this.relation.relatedModelClass;
+        this.maybeApplyAlias(builder);
+        this.relation.findQuery(builder, this.owner);
+        if (!builder.hasSelects()) {
+            const table = builder.tableRefFor(relatedModelClass);
+            // If the user hasn't specified a select clause, select the related model's columns.
+            // If we don't do this we also get the join table's columns.
+            builder.select(`${table}.*`);
+            // Also select all extra columns.
+            for (const extra of this.relation.joinTableExtras) {
+                const joinTable = builder.tableRefFor(this.relation.joinTable);
+                builder.select(`${joinTable}.${extra.joinTableCol} as ${extra.aliasCol}`);
+            }
         }
-
-        arr.push(rel);
-      }
-
-      for (let i = 0, l = owners.length; i < l; ++i) {
-        const own = owners[i];
-        const key = ownerProp.propKey(own);
-        const related = relatedByOwnerId.get(key);
-
-        if (isOneToOne) {
-          own[this.relationProperty] = (related && related[0]) || null;
-        } else {
-          own[this.relationProperty] = related || [];
+        if (this.assignResultToOwner && this.owner.isModels) {
+            this.selectMissingJoinColumns(builder);
         }
-      }
     }
-
-    return related;
-  }
-
-  clone() {
-    const clone = super.clone();
-    clone.ownerJoinColumnAlias = this.ownerJoinColumnAlias.slice();
-    return clone;
-  }
-
-  selectMissingJoinColumns(builder) {
-    const { relatedModelClass, joinTableOwnerProp } = this.relation;
-
-    // We must select the owner join columns so that we know for which owner model the related
-    // models belong to after the requests.
-    joinTableOwnerProp.forEach((i) => {
-      const joinTableOwnerRef = joinTableOwnerProp.ref(builder, i);
-      const propName = relatedModelClass.columnNameToPropertyName(this.ownerJoinColumnAlias[i]);
-
-      builder.select(joinTableOwnerRef.as(this.ownerJoinColumnAlias[i]));
-      // Mark them to be omitted later.
-      this.omitProps.push(propName);
-    });
-
-    super.selectMissingJoinColumns(builder);
-  }
+    onAfter2(_, related) {
+        const isOneToOne = this.relation.isOneToOne();
+        if (this.assignResultToOwner && this.owner.isModels) {
+            const owners = this.owner.modelArray;
+            const ownerProp = this.relation.ownerProp;
+            const relatedByOwnerId = new Map();
+            for (let i = 0, l = related.length; i < l; ++i) {
+                const rel = related[i];
+                const key = rel.$propKey(this.ownerJoinColumnAlias);
+                let arr = relatedByOwnerId.get(key);
+                if (!arr) {
+                    arr = [];
+                    relatedByOwnerId.set(key, arr);
+                }
+                arr.push(rel);
+            }
+            for (let i = 0, l = owners.length; i < l; ++i) {
+                const own = owners[i];
+                const key = ownerProp.propKey(own);
+                const related = relatedByOwnerId.get(key);
+                if (isOneToOne) {
+                    own[this.relationProperty] = (related && related[0]) || null;
+                }
+                else {
+                    own[this.relationProperty] = related || [];
+                }
+            }
+        }
+        return related;
+    }
+    clone() {
+        const clone = super.clone();
+        clone.ownerJoinColumnAlias = this.ownerJoinColumnAlias.slice();
+        return clone;
+    }
+    selectMissingJoinColumns(builder) {
+        const { relatedModelClass, joinTableOwnerProp } = this.relation;
+        // We must select the owner join columns so that we know for which owner model the related
+        // models belong to after the requests.
+        joinTableOwnerProp.forEach((i) => {
+            const joinTableOwnerRef = joinTableOwnerProp.ref(builder, i);
+            const propName = relatedModelClass.columnNameToPropertyName(this.ownerJoinColumnAlias[i]);
+            builder.select(joinTableOwnerRef.as(this.ownerJoinColumnAlias[i]));
+            // Mark them to be omitted later.
+            this.omitProps.push(propName);
+        });
+        super.selectMissingJoinColumns(builder);
+    }
 }
-
 module.exports = {
-  ManyToManyFindOperation,
+    ManyToManyFindOperation,
 };

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

@@ -1,52 +1,40 @@
 '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);
-      }
+    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;
     }
-
-    if (modelsToRelate.length === 0) {
-      return inserted;
+    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;
     }
-
-    relateOp.onAdd(builder, [modelsToRelate]);
-    await relateOp.queryExecutor(builder);
-
-    return inserted;
-  }
 }
-
 module.exports = {
-  ManyToManyInsertOperation,
+    ManyToManyInsertOperation,
 };

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

@@ -1,81 +1,64 @@
 '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)),
-        );
-      }
+    onAdd(builder, args) {
+        this.input = args[0];
+        this.ids = normalizeIds(args[0], this.relation.relatedProp);
+        assertOwnerIsSingleItem(builder, this.owner, this.relation);
+        return true;
     }
-
-    return joinModelClass
-      .query()
-      .childQueryOf(builder)
-      .modify((query) => {
-        if (!this.opt.dontCopyReturning) {
-          query.copyFrom(builder, /returning/);
+    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)));
+            }
         }
-
-        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;
-      });
-  }
+        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',
-      );
+    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(' '),
-      );
+    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,
+    ManyToManyRelateOperation,
 };

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

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

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

@@ -1,34 +1,27 @@
 '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');
-  }
+    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,
+    ManyToManyUnrelateOperationBase,
 };

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

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

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

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