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

package/lib/relations/manyToMany/ManyToManySqliteModifyMixin.js

@@ -1,36 +1,29 @@
-'use strict';
-
-const { ManyToManyModifyMixin } = require('./ManyToManyModifyMixin');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManyToManySqliteModifyMixin = void 0;
+const ManyToManyModifyMixin_1 = 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);
-    }
-  };
-};
-
-module.exports = {
-  ManyToManySqliteModifyMixin,
+    return class extends (0, ManyToManyModifyMixin_1.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);
+        }
+    };
 };
+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) {}
-
-module.exports = {
-  ManyToManyDeleteOperation,
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManyToManyDeleteOperation = void 0;
+const ManyToManyDeleteOperationBase_1 = require("./ManyToManyDeleteOperationBase");
+const ManyToManyModifyMixin_1 = require("../ManyToManyModifyMixin");
+class ManyToManyDeleteOperation extends (0, ManyToManyModifyMixin_1.ManyToManyModifyMixin)(ManyToManyDeleteOperationBase_1.ManyToManyDeleteOperationBase) {
+}
+exports.ManyToManyDeleteOperation = ManyToManyDeleteOperation;

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

@@ -1,26 +1,21 @@
-'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');
-  }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManyToManyDeleteOperationBase = void 0;
+const DeleteOperation_1 = require("../../../queryBuilder/operations/DeleteOperation");
+class ManyToManyDeleteOperationBase extends DeleteOperation_1.DeleteOperation {
+    constructor(name, opt) {
+        // @ts-expect-error The JavaScript QueryBuilderOperation's `name` is inferred as null.
+        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,
-};
+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,
-) {}
-
-module.exports = {
-  ManyToManyDeleteSqliteOperation,
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManyToManyDeleteSqliteOperation = void 0;
+const ManyToManyDeleteOperationBase_1 = require("./ManyToManyDeleteOperationBase");
+const ManyToManySqliteModifyMixin_1 = require("../ManyToManySqliteModifyMixin");
+class ManyToManyDeleteSqliteOperation extends (0, ManyToManySqliteModifyMixin_1.ManyToManySqliteModifyMixin)(ManyToManyDeleteOperationBase_1.ManyToManyDeleteOperationBase) {
+}
+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);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManyToManyFindOperation = void 0;
+const RelationFindOperation_1 = require("../../RelationFindOperation");
+const tmpColumnUtils_1 = require("../../../utils/tmpColumnUtils");
+class ManyToManyFindOperation extends RelationFindOperation_1.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] = (0, tmpColumnUtils_1.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,
-};
+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);
-      }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManyToManyInsertOperation = void 0;
+const RelationInsertOperation_1 = require("../../RelationInsertOperation");
+const ManyToManyRelateOperation_1 = require("../relate/ManyToManyRelateOperation");
+class ManyToManyInsertOperation extends RelationInsertOperation_1.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;
     }
-
-    if (modelsToRelate.length === 0) {
-      return inserted;
+    async onAfter1(builder, ret) {
+        const inserted = await super.onAfter1(builder, ret);
+        const relateOp = new ManyToManyRelateOperation_1.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,
-};
+exports.ManyToManyInsertOperation = ManyToManyInsertOperation;

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

@@ -1,81 +1,65 @@
-'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)),
-        );
-      }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManyToManyRelateOperation = void 0;
+const knexUtils_1 = require("../../../utils/knexUtils");
+const normalizeIds_1 = require("../../../utils/normalizeIds");
+const RelateOperation_1 = require("../../../queryBuilder/operations/RelateOperation");
+class ManyToManyRelateOperation extends RelateOperation_1.RelateOperation {
+    onAdd(builder, args) {
+        this.input = args[0];
+        // Without `arrayOutput`, these are id objects.
+        this.ids = (0, normalizeIds_1.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;
+        });
+    }
 }
-
+exports.ManyToManyRelateOperation = ManyToManyRelateOperation;
 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 ((0, knexUtils_1.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,
-};

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;
-  }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManyToManyUnrelateOperation = void 0;
+const ManyToManyUnrelateOperationBase_1 = require("./ManyToManyUnrelateOperationBase");
+const ManyToManyModifyMixin_1 = require("../ManyToManyModifyMixin");
+class ManyToManyUnrelateOperation extends (0, ManyToManyModifyMixin_1.ManyToManyModifyMixin)(ManyToManyUnrelateOperationBase_1.ManyToManyUnrelateOperationBase) {
+    get modifyMainQuery() {
+        return false;
+    }
 }
-
-module.exports = {
-  ManyToManyUnrelateOperation,
-};
+exports.ManyToManyUnrelateOperation = ManyToManyUnrelateOperation;